Attachment 1454839 Details for Bug 1595470 – proprocessed output

proprocessed output

h2-client.i (text/plain), 4.36 MB, created by Gene Hightower on 2018-06-27 00:13:13 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Gene Hightower

Created: 2018-06-27 00:13:13 UTC

Size: 4.36 MB

patch

obsolete

># 1 "h2-client.cpp"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "/usr/include/stdc-predef.h" 1 3 4
># 1 "<command-line>" 2
># 1 "h2-client.cpp"
># 1 "/usr/include/c++/8/iostream" 1 3
># 36 "/usr/include/c++/8/iostream" 3
> 
># 37 "/usr/include/c++/8/iostream" 3
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h" 1 3
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 4 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h" 2 3
># 2178 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h" 3
>
># 2178 "/usr/include/c++/8/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;
>
>}
># 2200 "/usr/include/c++/8/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"))) { }
>}
># 2450 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h" 3
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h" 1 3
># 39 "/usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h" 3
># 1 "/usr/include/features.h" 1 3 4
># 428 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 427 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 428 "/usr/include/sys/cdefs.h" 2 3 4
># 1 "/usr/include/bits/long-double.h" 1 3 4
># 429 "/usr/include/sys/cdefs.h" 2 3 4
># 429 "/usr/include/features.h" 2 3 4
># 452 "/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
># 453 "/usr/include/features.h" 2 3 4
># 40 "/usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h" 2 3
># 2451 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h" 2 3
>
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
># 2454 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h" 2 3
># 39 "/usr/include/c++/8/iostream" 2 3
># 1 "/usr/include/c++/8/ostream" 1 3
># 36 "/usr/include/c++/8/ostream" 3
> 
># 37 "/usr/include/c++/8/ostream" 3
>
># 1 "/usr/include/c++/8/ios" 1 3
># 36 "/usr/include/c++/8/ios" 3
> 
># 37 "/usr/include/c++/8/ios" 3
>
># 1 "/usr/include/c++/8/iosfwd" 1 3
># 36 "/usr/include/c++/8/iosfwd" 3
> 
># 37 "/usr/include/c++/8/iosfwd" 3
>
>
># 1 "/usr/include/c++/8/bits/stringfwd.h" 1 3
># 37 "/usr/include/c++/8/bits/stringfwd.h" 3
> 
># 38 "/usr/include/c++/8/bits/stringfwd.h" 3
>
>
># 1 "/usr/include/c++/8/bits/memoryfwd.h" 1 3
># 46 "/usr/include/c++/8/bits/memoryfwd.h" 3
> 
># 47 "/usr/include/c++/8/bits/memoryfwd.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 63 "/usr/include/c++/8/bits/memoryfwd.h" 3
> template<typename>
> class allocator;
>
> template<>
> class allocator<void>;
>
>
> template<typename, typename>
> struct uses_allocator;
>
>
>
>
>}
># 41 "/usr/include/c++/8/bits/stringfwd.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<class _CharT>
> struct char_traits;
>
> template<> struct char_traits<char>;
>
>
> template<> struct char_traits<wchar_t>;
>
>
>
>
> template<> struct char_traits<char16_t>;
> template<> struct char_traits<char32_t>;
>
>
>namespace __cxx11 {
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_string;
>
>
> typedef basic_string<char> string;
>
>
>
> typedef basic_string<wchar_t> wstring;
>
>
>
>
>
> typedef basic_string<char16_t> u16string;
>
>
> typedef basic_string<char32_t> u32string;
>
>
>}
>
>
>
>
>}
># 40 "/usr/include/c++/8/iosfwd" 2 3
># 1 "/usr/include/c++/8/bits/postypes.h" 1 3
># 38 "/usr/include/c++/8/bits/postypes.h" 3
> 
># 39 "/usr/include/c++/8/bits/postypes.h" 3
>
># 1 "/usr/include/c++/8/cwchar" 1 3
># 39 "/usr/include/c++/8/cwchar" 3
> 
># 40 "/usr/include/c++/8/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
># 74 "/usr/include/bits/floatn.h" 3 4
>typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
># 86 "/usr/include/bits/floatn.h" 3 4
>typedef __float128 _Float128;
># 119 "/usr/include/bits/floatn.h" 3 4
># 1 "/usr/include/bits/floatn-common.h" 1 3 4
># 24 "/usr/include/bits/floatn-common.h" 3 4
># 1 "/usr/include/bits/long-double.h" 1 3 4
># 25 "/usr/include/bits/floatn-common.h" 2 3 4
># 207 "/usr/include/bits/floatn-common.h" 3 4
>typedef float _Float32;
># 244 "/usr/include/bits/floatn-common.h" 3 4
>typedef double _Float64;
># 261 "/usr/include/bits/floatn-common.h" 3 4
>typedef double _Float32x;
># 278 "/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 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 216 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 36 "/usr/include/wchar.h" 2 3 4
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 39 "/usr/include/wchar.h" 2 3 4
>
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 41 "/usr/include/wchar.h" 2 3 4
># 1 "/usr/include/bits/types/wint_t.h" 1 3 4
># 20 "/usr/include/bits/types/wint_t.h" 3 4
>typedef unsigned int wint_t;
># 42 "/usr/include/wchar.h" 2 3 4
># 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4
># 13 "/usr/include/bits/types/__mbstate_t.h" 3 4
>typedef struct
>{
> int __count;
> union
> {
> unsigned int __wch;
> char __wchb[4];
> } __value;
>} __mbstate_t;
># 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4
>
>typedef __mbstate_t mbstate_t;
># 43 "/usr/include/wchar.h" 2 3 4
># 1 "/usr/include/bits/types/__FILE.h" 1 3 4
>
>
>
>struct _IO_FILE;
>typedef struct _IO_FILE __FILE;
># 44 "/usr/include/wchar.h" 2 3 4
>
>
># 1 "/usr/include/bits/types/FILE.h" 1 3 4
>
>
>
>struct _IO_FILE;
>
>
>typedef struct _IO_FILE FILE;
># 47 "/usr/include/wchar.h" 2 3 4
>
>
># 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)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern wchar_t *wcscat (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern wchar_t *wcsncat (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
>
>
>extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
> size_t __n) throw ();
>
>
>
>extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
> locale_t __loc) throw ();
>
>extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
> size_t __n, locale_t __loc) throw ();
>
>
>
>
>extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
>
>
>
>extern size_t wcsxfrm (wchar_t *__restrict __s1,
> const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>
>
>
>
>extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
> locale_t __loc) throw ();
>
>
>
>
>extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
> size_t __n, locale_t __loc) throw ();
>
>
>extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
>
>
>
>
>extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcschr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcschr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcsrchr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
> throw () __asm ("wcsrchr") __attribute__ ((__pure__));
># 181 "/usr/include/wchar.h" 3 4
>extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
> throw () __attribute__ ((__pure__));
>
>
>
>
>extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
> throw () __attribute__ ((__pure__));
>
>
>extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
> throw () __attribute__ ((__pure__));
>
>
>extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
> throw () __asm ("wcspbrk") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
> const wchar_t *__accept)
> throw () __asm ("wcspbrk") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
> throw () __asm ("wcsstr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
> const wchar_t *__needle)
> throw () __asm ("wcsstr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern wchar_t *wcstok (wchar_t *__restrict __s,
> const wchar_t *__restrict __delim,
> wchar_t **__restrict __ptr) throw ();
>
>
>extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
>
>
>
>
>extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
> throw () __asm ("wcswcs") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
> const wchar_t *__needle)
> throw () __asm ("wcswcs") __attribute__ ((__pure__));
># 240 "/usr/include/wchar.h" 3 4
>extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
> throw () __attribute__ ((__pure__));
>
>
>
>
>
>extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
> throw () __asm ("wmemchr") __attribute__ ((__pure__));
>extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
> size_t __n)
> throw () __asm ("wmemchr") __attribute__ ((__pure__));
>
>
>
>
>
>
>extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
> throw () __attribute__ ((__pure__));
>
>
>extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
> const wchar_t *__restrict __s2, size_t __n) throw ();
>
>
>
>extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
> throw ();
>
>
>extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
>
>
>
>
>extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
> const wchar_t *__restrict __s2, size_t __n)
> throw ();
>
>
>
>
>
>extern wint_t btowc (int __c) throw ();
>
>
>
>extern int wctob (wint_t __c) throw ();
>
>
>
>extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
>
>
>
>extern size_t mbrtowc (wchar_t *__restrict __pwc,
> const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __p) throw ();
>
>
>extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
> mbstate_t *__restrict __ps) throw ();
>
>
>extern size_t __mbrlen (const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __ps) throw ();
>extern size_t mbrlen (const char *__restrict __s, size_t __n,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>
>extern wint_t __btowc_alias (int __c) __asm ("btowc");
>extern __inline __attribute__ ((__gnu_inline__)) wint_t
>__attribute__ ((__leaf__)) btowc (int __c) throw ()
>{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
> ? (wint_t) __c : __btowc_alias (__c)); }
>
>extern int __wctob_alias (wint_t __c) __asm ("wctob");
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
>{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
> ? (int) __wc : __wctob_alias (__wc)); }
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__attribute__ ((__leaf__)) mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
>
>{ return (__ps != __null
> ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
>
>
>
>
>extern size_t mbsrtowcs (wchar_t *__restrict __dst,
> const char **__restrict __src, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsrtombs (char *__restrict __dst,
> const wchar_t **__restrict __src, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
> const char **__restrict __src, size_t __nmc,
> size_t __len, mbstate_t *__restrict __ps) throw ();
>
>
>
>extern size_t wcsnrtombs (char *__restrict __dst,
> const wchar_t **__restrict __src,
> size_t __nwc, size_t __len,
> mbstate_t *__restrict __ps) throw ();
>
>
>
>
>
>
>extern int wcwidth (wchar_t __c) throw ();
>
>
>
>extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
>
>
>
>
>
>extern double wcstod (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>extern float wcstof (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>extern long double wcstold (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
># 396 "/usr/include/wchar.h" 3 4
>extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
>
>
>
>extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr) throw ();
># 428 "/usr/include/wchar.h" 3 4
>extern long int wcstol (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base) throw ();
>
>
>
>extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>
>__extension__
>extern long long int wcstoll (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base) throw ();
>
>
>
>
>
>__extension__
>extern long long int wcstoq (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>
>__extension__
>extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base) throw ();
>
>
>
>
>
>
>extern long int wcstol_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base,
> locale_t __loc) throw ();
>
>extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, locale_t __loc) throw ();
>
>__extension__
>extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, locale_t __loc) throw ();
>
>__extension__
>extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, locale_t __loc)
> throw ();
>
>extern double wcstod_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, locale_t __loc)
> throw ();
>
>extern float wcstof_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, locale_t __loc)
> throw ();
>
>extern long double wcstold_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> locale_t __loc) throw ();
># 511 "/usr/include/wchar.h" 3 4
>extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> locale_t __loc) throw ();
>
>
>
>extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> locale_t __loc) throw ();
>
>
>
>extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> locale_t __loc) throw ();
>
>
>
>extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> locale_t __loc) throw ();
>
>
>
>extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr,
> locale_t __loc) throw ();
># 551 "/usr/include/wchar.h" 3 4
>extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src) throw ();
>
>
>
>extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
> const wchar_t *__restrict __src, size_t __n)
> throw ();
># 567 "/usr/include/wchar.h" 3 4
>extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
>
>
>
>
>
>extern int fwide (__FILE *__fp, int __mode) throw ();
>
>
>
>
>
>
>extern int fwprintf (__FILE *__restrict __stream,
> const wchar_t *__restrict __format, ...)
> ;
>
>
>
>
>extern int wprintf (const wchar_t *__restrict __format, ...)
> ;
>
>extern int swprintf (wchar_t *__restrict __s, size_t __n,
> const wchar_t *__restrict __format, ...)
> throw () ;
>
>
>
>
>
>extern int vfwprintf (__FILE *__restrict __s,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>
>
>extern int vwprintf (const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>extern int vswprintf (wchar_t *__restrict __s, size_t __n,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> throw () ;
>
>
>
>
>
>
>extern int fwscanf (__FILE *__restrict __stream,
> const wchar_t *__restrict __format, ...)
> ;
>
>
>
>
>extern int wscanf (const wchar_t *__restrict __format, ...)
> ;
>
>extern int swscanf (const wchar_t *__restrict __s,
> const wchar_t *__restrict __format, ...)
> throw () ;
># 673 "/usr/include/wchar.h" 3 4
>extern int vfwscanf (__FILE *__restrict __s,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>
>
>
>extern int vwscanf (const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> ;
>
>extern int vswscanf (const wchar_t *__restrict __s,
> const wchar_t *__restrict __format,
> __gnuc_va_list __arg)
> throw () ;
># 727 "/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);
># 782 "/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);
># 808 "/usr/include/wchar.h" 3 4
>extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
>extern wint_t putwchar_unlocked (wchar_t __wc);
># 818 "/usr/include/wchar.h" 3 4
>extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern int fputws_unlocked (const wchar_t *__restrict __ws,
> __FILE *__restrict __stream);
>
>
>
>
>
>
>extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
> const wchar_t *__restrict __format,
> const struct tm *__restrict __tp) throw ();
>
>
>
>
>extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
> const wchar_t *__restrict __format,
> const struct tm *__restrict __tp,
> locale_t __loc) throw ();
># 857 "/usr/include/wchar.h" 3 4
>}
># 45 "/usr/include/c++/8/cwchar" 2 3
># 62 "/usr/include/c++/8/cwchar" 3
>namespace std
>{
> using ::mbstate_t;
>}
># 135 "/usr/include/c++/8/cwchar" 3
>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;
># 232 "/usr/include/c++/8/cwchar" 3
>
>}
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
> using ::wcstold;
># 257 "/usr/include/c++/8/cwchar" 3
> using ::wcstoll;
> using ::wcstoull;
>
>}
>
>namespace std
>{
> using ::__gnu_cxx::wcstold;
> using ::__gnu_cxx::wcstoll;
> using ::__gnu_cxx::wcstoull;
>}
># 277 "/usr/include/c++/8/cwchar" 3
>namespace std
>{
>
> using std::wcstof;
>
>
> using std::vfwscanf;
>
>
> using std::vswscanf;
>
>
> using std::vwscanf;
>
>
>
> using std::wcstold;
> using std::wcstoll;
> using std::wcstoull;
>
>}
># 41 "/usr/include/c++/8/bits/postypes.h" 2 3
># 68 "/usr/include/c++/8/bits/postypes.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 88 "/usr/include/c++/8/bits/postypes.h" 3
> typedef long streamoff;
># 98 "/usr/include/c++/8/bits/postypes.h" 3
> typedef ptrdiff_t streamsize;
># 111 "/usr/include/c++/8/bits/postypes.h" 3
> template<typename _StateT>
> class fpos
> {
> private:
> streamoff _M_off;
> _StateT _M_state;
>
> public:
>
>
>
>
> fpos()
> : _M_off(0), _M_state() { }
># 133 "/usr/include/c++/8/bits/postypes.h" 3
> fpos(streamoff __off)
> : _M_off(__off), _M_state() { }
>
>
> 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> u16streampos;
>
> typedef fpos<mbstate_t> u32streampos;
>
>
>
>}
># 41 "/usr/include/c++/8/iosfwd" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 74 "/usr/include/c++/8/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;
>
>
>
>
>}
># 39 "/usr/include/c++/8/ios" 2 3
># 1 "/usr/include/c++/8/exception" 1 3
># 33 "/usr/include/c++/8/exception" 3
> 
># 34 "/usr/include/c++/8/exception" 3
>
>#pragma GCC visibility push(default)
>
>
># 1 "/usr/include/c++/8/bits/exception.h" 1 3
># 34 "/usr/include/c++/8/bits/exception.h" 3
> 
># 35 "/usr/include/c++/8/bits/exception.h" 3
>
>#pragma GCC visibility push(default)
>
>
>
>extern "C++" {
>
>namespace std
>{
># 60 "/usr/include/c++/8/bits/exception.h" 3
> class exception
> {
> public:
> exception() noexcept { }
> virtual ~exception() noexcept;
>
>
>
> virtual const char*
> what() const noexcept;
> };
>
>}
>
>}
>
>#pragma GCC visibility pop
># 39 "/usr/include/c++/8/exception" 2 3
>
>extern "C++" {
>
>namespace std
>{
>
>
> class bad_exception : public exception
> {
> public:
> bad_exception() noexcept { }
>
>
>
> virtual ~bad_exception() noexcept;
>
>
> virtual const char*
> what() const noexcept;
> };
>
>
> typedef void (*terminate_handler) ();
>
>
> typedef void (*unexpected_handler) ();
>
>
> terminate_handler set_terminate(terminate_handler) noexcept;
>
>
>
> terminate_handler get_terminate() noexcept;
>
>
>
>
> void terminate() noexcept __attribute__ ((__noreturn__));
>
>
> unexpected_handler set_unexpected(unexpected_handler) noexcept;
>
>
>
> unexpected_handler get_unexpected() noexcept;
>
>
>
>
> void unexpected() __attribute__ ((__noreturn__));
># 101 "/usr/include/c++/8/exception" 3
> [[__deprecated__]]
> bool uncaught_exception() noexcept __attribute__ ((__pure__));
>
>
>
>
> int uncaught_exceptions() noexcept __attribute__ ((__pure__));
>
>
>
>}
>
>namespace __gnu_cxx
>{
>
># 133 "/usr/include/c++/8/exception" 3
> void __verbose_terminate_handler();
>
>
>}
>
>}
>
>#pragma GCC visibility pop
>
>
># 1 "/usr/include/c++/8/bits/exception_ptr.h" 1 3
># 34 "/usr/include/c++/8/bits/exception_ptr.h" 3
>#pragma GCC visibility push(default)
>
>
># 1 "/usr/include/c++/8/bits/exception_defines.h" 1 3
># 38 "/usr/include/c++/8/bits/exception_ptr.h" 2 3
># 1 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 1 3
># 34 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 3
> 
># 35 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 3
>
>#pragma GCC visibility push(default)
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 149 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 426 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 3 4
>typedef struct {
> long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
> long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
># 437 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 3 4
>} max_align_t;
>
>
>
>
>
>
> typedef decltype(nullptr) nullptr_t;
># 39 "/usr/include/c++/8/bits/cxxabi_init_exception.h" 2 3
># 50 "/usr/include/c++/8/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;
>
>
> __cxa_refcounted_exception*
> __cxa_init_primary_exception(void *object, std::type_info *tinfo,
> void ( *dest) (void *)) noexcept;
>
> }
>}
>
>
>
>#pragma GCC visibility pop
># 39 "/usr/include/c++/8/bits/exception_ptr.h" 2 3
># 1 "/usr/include/c++/8/typeinfo" 1 3
># 32 "/usr/include/c++/8/typeinfo" 3
> 
># 33 "/usr/include/c++/8/typeinfo" 3
>
>
>
># 1 "/usr/include/c++/8/bits/hash_bytes.h" 1 3
># 33 "/usr/include/c++/8/bits/hash_bytes.h" 3
> 
># 34 "/usr/include/c++/8/bits/hash_bytes.h" 3
>
>
>
>namespace std
>{
>
>
>
>
>
>
>
> size_t
> _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>
>
>
> size_t
> _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>}
># 37 "/usr/include/c++/8/typeinfo" 2 3
>
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace __cxxabiv1
>{
> class __class_type_info;
>}
># 80 "/usr/include/c++/8/typeinfo" 3
>namespace std
>{
>
>
>
>
>
>
> class type_info
> {
> public:
>
>
>
>
> virtual ~type_info();
>
>
>
> const char* name() const noexcept
> { return __name[0] == '*' ? __name + 1 : __name; }
># 115 "/usr/include/c++/8/typeinfo" 3
> bool before(const type_info& __arg) const noexcept
> { return (__name[0] == '*' && __arg.__name[0] == '*')
> ? __name < __arg.__name
> : __builtin_strcmp (__name, __arg.__name) < 0; }
>
> bool operator==(const type_info& __arg) const noexcept
> {
> return ((__name == __arg.__name)
> || (__name[0] != '*' &&
> __builtin_strcmp (__name, __arg.__name) == 0));
> }
># 136 "/usr/include/c++/8/typeinfo" 3
> bool operator!=(const type_info& __arg) const noexcept
> { return !operator==(__arg); }
>
>
> size_t hash_code() const noexcept
> {
>
> return _Hash_bytes(name(), __builtin_strlen(name()),
> static_cast<size_t>(0xc70f6907UL));
>
>
>
> }
>
>
>
> virtual bool __is_pointer_p() const;
>
>
> virtual bool __is_function_p() const;
>
>
>
>
>
>
>
> virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
> unsigned __outer) const;
>
>
> virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
> void **__obj_ptr) const;
>
> protected:
> const char *__name;
>
> explicit type_info(const char *__n): __name(__n) { }
>
> private:
>
> type_info& operator=(const type_info&);
> type_info(const type_info&);
> };
>
>
>
>
>
>
>
> class bad_cast : public exception
> {
> public:
> bad_cast() noexcept { }
>
>
>
> virtual ~bad_cast() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>
>
>
>
>
> class bad_typeid : public exception
> {
> public:
> bad_typeid () noexcept { }
>
>
>
> virtual ~bad_typeid() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>}
>
>}
>
>#pragma GCC visibility pop
># 40 "/usr/include/c++/8/bits/exception_ptr.h" 2 3
># 1 "/usr/include/c++/8/new" 1 3
># 37 "/usr/include/c++/8/new" 3
> 
># 38 "/usr/include/c++/8/new" 3
>
>
># 1 "/usr/include/c++/8/exception" 1 3
># 41 "/usr/include/c++/8/new" 2 3
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class bad_alloc : public exception
> {
> public:
> bad_alloc() throw() { }
>
>
>
> 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;
>
>}
># 120 "/usr/include/c++/8/new" 3
>void* operator new(std::size_t)
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t)
> __attribute__((__externally_visible__));
>void operator delete(void*) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*) noexcept
> __attribute__((__externally_visible__));
>
>void operator delete(void*, std::size_t) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*, std::size_t) noexcept
> __attribute__((__externally_visible__));
>
>void* operator new(std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete(void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>
>void* operator new(std::size_t, std::align_val_t)
> __attribute__((__externally_visible__));
>void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
> noexcept __attribute__((__externally_visible__));
>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 new[](std::size_t, std::align_val_t)
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
> noexcept __attribute__((__externally_visible__));
>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__));
>
>
>
>
>inline void* operator new(std::size_t, void* __p) noexcept
>{ return __p; }
>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 { }
>
>}
># 190 "/usr/include/c++/8/new" 3
>namespace std
>{
>
>
> template<typename _Tp>
> [[nodiscard]] constexpr _Tp*
> launder(_Tp* __p) noexcept
> { return __builtin_launder(__p); }
>
>
>
>
> template<typename _Ret, typename... _Args , bool _NE>
> void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete;
> template<typename _Ret, typename... _Args , bool _NE>
> void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete;
>
> void launder(void*) = delete;
> void launder(const void*) = delete;
> void launder(volatile void*) = delete;
> void launder(const volatile void*) = delete;
>}
>
>
>
>
>#pragma GCC visibility pop
># 41 "/usr/include/c++/8/bits/exception_ptr.h" 2 3
>
>extern "C++" {
>
>namespace std
>{
> class type_info;
>
>
>
>
>
> namespace __exception_ptr
> {
> class exception_ptr;
> }
>
> using __exception_ptr::exception_ptr;
>
>
>
>
>
> exception_ptr current_exception() noexcept;
>
> template<typename _Ex>
> exception_ptr make_exception_ptr(_Ex) noexcept;
>
>
> void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
>
> namespace __exception_ptr
> {
> using std::rethrow_exception;
>
>
>
>
>
> class exception_ptr
> {
> void* _M_exception_object;
>
> explicit exception_ptr(void* __e) noexcept;
>
> void _M_addref() noexcept;
> void _M_release() noexcept;
>
> void *_M_get() const noexcept __attribute__ ((__pure__));
>
> friend exception_ptr std::current_exception() noexcept;
> friend void std::rethrow_exception(exception_ptr);
> template<typename _Ex>
> friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
>
> public:
> exception_ptr() noexcept;
>
> exception_ptr(const exception_ptr&) noexcept;
>
>
> exception_ptr(nullptr_t) noexcept
> : _M_exception_object(0)
> { }
>
> exception_ptr(exception_ptr&& __o) noexcept
> : _M_exception_object(__o._M_exception_object)
> { __o._M_exception_object = 0; }
># 117 "/usr/include/c++/8/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;
># 144 "/usr/include/c++/8/bits/exception_ptr.h" 3
> explicit operator bool() const
> { return _M_exception_object; }
>
>
> friend bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> const class std::type_info*
> __cxa_exception_type() const noexcept
> __attribute__ ((__pure__));
> };
>
> bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> bool
> operator!=(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> inline void
> swap(exception_ptr& __lhs, exception_ptr& __rhs)
> { __lhs.swap(__rhs); }
>
> template<typename _Ex>
> inline void
> __dest_thunk(void* __x)
> { static_cast<_Ex*>(__x)->~_Ex(); }
>
> }
>
>
> template<typename _Ex>
> exception_ptr
> make_exception_ptr(_Ex __ex) noexcept
> {
>
> try
> {
>
> void *__e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
> (void)__cxxabiv1::__cxa_init_primary_exception(
> __e, const_cast<std::type_info*>(&typeid(__ex)),
> __exception_ptr::__dest_thunk<_Ex>);
> ::new (__e) _Ex(__ex);
> return exception_ptr(__e);
>
>
>
> }
> catch(...)
> {
> return current_exception();
> }
>
>
>
> }
>
>
>}
>
>}
>
>#pragma GCC visibility pop
># 144 "/usr/include/c++/8/exception" 2 3
># 1 "/usr/include/c++/8/bits/nested_exception.h" 1 3
># 33 "/usr/include/c++/8/bits/nested_exception.h" 3
>#pragma GCC visibility push(default)
>
>
>
>
>
>
># 1 "/usr/include/c++/8/bits/move.h" 1 3
># 34 "/usr/include/c++/8/bits/move.h" 3
># 1 "/usr/include/c++/8/bits/concept_check.h" 1 3
># 33 "/usr/include/c++/8/bits/concept_check.h" 3
> 
># 34 "/usr/include/c++/8/bits/concept_check.h" 3
># 35 "/usr/include/c++/8/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _Tp>
> inline constexpr _Tp*
> __addressof(_Tp& __r) noexcept
> { return __builtin_addressof(__r); }
>
>
>
>
>}
>
># 1 "/usr/include/c++/8/type_traits" 1 3
># 32 "/usr/include/c++/8/type_traits" 3
> 
># 33 "/usr/include/c++/8/type_traits" 3
># 42 "/usr/include/c++/8/type_traits" 3
>namespace std
>{
> typedef short unsigned int uint_least16_t;
> typedef unsigned int uint_least32_t;
>}
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 68 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp, _Tp __v>
> struct integral_constant
> {
> static constexpr _Tp value = __v;
> typedef _Tp value_type;
> typedef integral_constant<_Tp, __v> type;
> constexpr operator value_type() const noexcept { return value; }
>
>
>
>
> constexpr value_type operator()() const noexcept { return value; }
>
> };
>
> template<typename _Tp, _Tp __v>
> constexpr _Tp integral_constant<_Tp, __v>::value;
>
>
> typedef integral_constant<bool, true> true_type;
>
>
> typedef integral_constant<bool, false> false_type;
>
> template<bool __v>
> using __bool_constant = integral_constant<bool, __v>;
>
>
>
> template<bool __v>
> using bool_constant = integral_constant<bool, __v>;
>
>
>
>
> template<bool, typename, typename>
> struct conditional;
>
> template<typename...>
> struct __or_;
>
> template<>
> struct __or_<>
> : public false_type
> { };
>
> template<typename _B1>
> struct __or_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __or_<_B1, _B2>
> : public conditional<_B1::value, _B1, _B2>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __or_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
> { };
>
> template<typename...>
> struct __and_;
>
> template<>
> struct __and_<>
> : public true_type
> { };
>
> template<typename _B1>
> struct __and_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __and_<_B1, _B2>
> : public conditional<_B1::value, _B2, _B1>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __and_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
> { };
>
> template<typename _Pp>
> struct __not_
> : public __bool_constant<!bool(_Pp::value)>
> { };
>
>
>
>
>
> template<typename... _Bn>
> struct conjunction
> : __and_<_Bn...>
> { };
>
> template<typename... _Bn>
> struct disjunction
> : __or_<_Bn...>
> { };
>
> template<typename _Pp>
> struct negation
> : __not_<_Pp>
> { };
>
> template<typename... _Bn>
> inline constexpr bool conjunction_v = conjunction<_Bn...>::value;
>
> template<typename... _Bn>
> inline constexpr bool disjunction_v = disjunction<_Bn...>::value;
>
> template<typename _Pp>
> inline constexpr bool negation_v = negation<_Pp>::value;
># 192 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp>
> struct __success_type
> { typedef _Tp type; };
>
> struct __failure_type
> { };
>
>
>
> template<typename>
> struct remove_cv;
>
> template<typename>
> struct __is_void_helper
> : public false_type { };
>
> template<>
> struct __is_void_helper<void>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_void
> : public __is_void_helper<typename remove_cv<_Tp>::type>::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<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 { };
># 324 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp>
> struct is_integral
> : public __is_integral_helper<typename remove_cv<_Tp>::type>::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 { };
># 352 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp>
> struct is_floating_point
> : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
> { };
>
>
> template<typename>
> struct is_array
> : public false_type { };
>
> template<typename _Tp, std::size_t _Size>
> struct is_array<_Tp[_Size]>
> : public true_type { };
>
> template<typename _Tp>
> struct is_array<_Tp[]>
> : public true_type { };
>
> template<typename>
> struct __is_pointer_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_pointer_helper<_Tp*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_pointer
> : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
> { };
>
>
> template<typename>
> struct is_lvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_lvalue_reference<_Tp&>
> : public true_type { };
>
>
> template<typename>
> struct is_rvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_rvalue_reference<_Tp&&>
> : public true_type { };
>
> template<typename>
> struct is_function;
>
> template<typename>
> struct __is_member_object_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_object_pointer_helper<_Tp _Cp::*>
> : public integral_constant<bool, !is_function<_Tp>::value> { };
>
>
> template<typename _Tp>
> struct is_member_object_pointer
> : public __is_member_object_pointer_helper<
> typename remove_cv<_Tp>::type>::type
> { };
>
> template<typename>
> struct __is_member_function_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_function_pointer_helper<_Tp _Cp::*>
> : public integral_constant<bool, is_function<_Tp>::value> { };
>
>
> template<typename _Tp>
> struct is_member_function_pointer
> : public __is_member_function_pointer_helper<
> typename remove_cv<_Tp>::type>::type
> { };
>
>
> template<typename _Tp>
> struct is_enum
> : public integral_constant<bool, __is_enum(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_union
> : public integral_constant<bool, __is_union(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_class
> : public integral_constant<bool, __is_class(_Tp)>
> { };
>
>
> template<typename>
> struct is_function
> : public false_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) const noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) const & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) const && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) const noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) const & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) const && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) volatile noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) volatile & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) volatile && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) volatile noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) volatile & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) volatile && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) const volatile noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) const volatile & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes...) const volatile && noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) const volatile noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) const volatile & noexcept (_NE)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct is_function<_Res(_ArgTypes......) const volatile && noexcept (_NE)>
> : public true_type { };
>
>
>
> template<typename>
> struct __is_null_pointer_helper
> : public false_type { };
>
> template<>
> struct __is_null_pointer_helper<std::nullptr_t>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_null_pointer
> : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
> { };
>
>
> template<typename _Tp>
> struct __is_nullptr_t
> : public is_null_pointer<_Tp>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_reference
> : public __or_<is_lvalue_reference<_Tp>,
> is_rvalue_reference<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_arithmetic
> : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_fundamental
> : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
> is_null_pointer<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_object
> : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
> is_void<_Tp>>>::type
> { };
>
> template<typename>
> struct is_member_pointer;
>
>
> template<typename _Tp>
> struct is_scalar
> : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
> is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_compound
> : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
>
> template<typename _Tp>
> struct __is_member_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_pointer_helper<_Tp _Cp::*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_member_pointer
> : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
> { };
>
>
>
> template<typename _Tp>
> struct __is_referenceable
> : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
> { };
>
> template<typename _Res, typename... _Args , bool _NE>
> struct __is_referenceable<_Res(_Args...) noexcept (_NE)>
> : public true_type
> { };
>
> template<typename _Res, typename... _Args , bool _NE>
> struct __is_referenceable<_Res(_Args......) noexcept (_NE)>
> : public true_type
> { };
>
>
>
>
> template<typename>
> struct is_const
> : public false_type { };
>
> template<typename _Tp>
> struct is_const<_Tp const>
> : public true_type { };
>
>
> template<typename>
> struct is_volatile
> : public false_type { };
>
> template<typename _Tp>
> struct is_volatile<_Tp volatile>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_trivial
> : public integral_constant<bool, __is_trivial(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_copyable
> : public integral_constant<bool, __is_trivially_copyable(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_standard_layout
> : public integral_constant<bool, __is_standard_layout(_Tp)>
> { };
>
>
>
> template<typename _Tp>
> struct is_pod
> : public integral_constant<bool, __is_pod(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_literal_type
> : public integral_constant<bool, __is_literal_type(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_empty
> : public integral_constant<bool, __is_empty(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_polymorphic
> : public integral_constant<bool, __is_polymorphic(_Tp)>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_final
> : public integral_constant<bool, __is_final(_Tp)>
> { };
>
>
>
> template<typename _Tp>
> struct is_abstract
> : public integral_constant<bool, __is_abstract(_Tp)>
> { };
>
> template<typename _Tp,
> bool = is_arithmetic<_Tp>::value>
> struct __is_signed_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_signed_helper<_Tp, true>
> : public integral_constant<bool, _Tp(-1) < _Tp(0)>
> { };
>
>
> template<typename _Tp>
> struct is_signed
> : public __is_signed_helper<_Tp>::type
> { };
>
>
> template<typename _Tp>
> struct is_unsigned
> : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
> { };
># 759 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp, typename _Up = _Tp&&>
> _Up
> __declval(int);
>
> template<typename _Tp>
> _Tp
> __declval(long);
>
> template<typename _Tp>
> auto declval() noexcept -> decltype(__declval<_Tp>(0));
>
> template<typename, unsigned = 0>
> struct extent;
>
> template<typename>
> struct remove_all_extents;
>
> template<typename _Tp>
> struct __is_array_known_bounds
> : public integral_constant<bool, (extent<_Tp>::value > 0)>
> { };
>
> template<typename _Tp>
> struct __is_array_unknown_bounds
> : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
> { };
>
>
>
>
>
>
> struct __do_is_destructible_impl
> {
> template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_destructible_impl
> : public __do_is_destructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>,
> is_function<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
> struct __is_destructible_safe;
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, false>
> : public __is_destructible_impl<typename
> remove_all_extents<_Tp>::type>::type
> { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_destructible
> : public __is_destructible_safe<_Tp>::type
> { };
>
>
>
>
>
> struct __do_is_nt_destructible_impl
> {
> template<typename _Tp>
> static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
> __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_nt_destructible_impl
> : public __do_is_nt_destructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>,
> is_function<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
> struct __is_nt_destructible_safe;
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, false, false>
> : public __is_nt_destructible_impl<typename
> remove_all_extents<_Tp>::type>::type
> { };
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_nothrow_destructible
> : public __is_nt_destructible_safe<_Tp>::type
> { };
>
> struct __do_is_default_constructible_impl
> {
> template<typename _Tp, typename = decltype(_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_default_constructible_impl
> : public __do_is_default_constructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_default_constructible_atom
> : public __and_<__not_<is_void<_Tp>>,
> __is_default_constructible_impl<_Tp>>
> { };
>
> template<typename _Tp, bool = is_array<_Tp>::value>
> struct __is_default_constructible_safe;
>
>
>
>
>
>
> template<typename _Tp>
> struct __is_default_constructible_safe<_Tp, true>
> : public __and_<__is_array_known_bounds<_Tp>,
> __is_default_constructible_atom<typename
> remove_all_extents<_Tp>::type>>
> { };
>
> template<typename _Tp>
> struct __is_default_constructible_safe<_Tp, false>
> : public __is_default_constructible_atom<_Tp>::type
> { };
>
>
> template<typename _Tp>
> struct is_default_constructible
> : public __is_default_constructible_safe<_Tp>::type
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_constructible
> : public __bool_constant<__is_constructible(_Tp, _Args...)>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, true>
> : public is_constructible<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_constructible
> : public __is_copy_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, true>
> : public is_constructible<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_constructible
> : public __is_move_constructible_impl<_Tp>
> { };
>
> template<typename _Tp>
> struct __is_nt_default_constructible_atom
> : public integral_constant<bool, noexcept(_Tp())>
> { };
>
> template<typename _Tp, bool = is_array<_Tp>::value>
> struct __is_nt_default_constructible_impl;
>
> template<typename _Tp>
> struct __is_nt_default_constructible_impl<_Tp, true>
> : public __and_<__is_array_known_bounds<_Tp>,
> __is_nt_default_constructible_atom<typename
> remove_all_extents<_Tp>::type>>
> { };
>
> template<typename _Tp>
> struct __is_nt_default_constructible_impl<_Tp, false>
> : public __is_nt_default_constructible_atom<_Tp>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_default_constructible
> : public __and_<is_default_constructible<_Tp>,
> __is_nt_default_constructible_impl<_Tp>>
> { };
>
> template<typename _Tp, typename... _Args>
> struct __is_nt_constructible_impl
> : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_nt_constructible_impl<_Tp, _Arg>
> : public integral_constant<bool,
> noexcept(static_cast<_Tp>(declval<_Arg>()))>
> { };
>
> template<typename _Tp>
> struct __is_nt_constructible_impl<_Tp>
> : public is_nothrow_default_constructible<_Tp>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_nothrow_constructible
> : public __and_<is_constructible<_Tp, _Args...>,
> __is_nt_constructible_impl<_Tp, _Args...>>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nothrow_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, true>
> : public is_nothrow_constructible<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_constructible
> : public __is_nothrow_copy_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nothrow_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, true>
> : public is_nothrow_constructible<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_constructible
> : public __is_nothrow_move_constructible_impl<_Tp>
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_assignable
> : public __bool_constant<__is_assignable(_Tp, _Up)>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, true>
> : public is_assignable<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_assignable
> : public __is_copy_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, true>
> : public is_assignable<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_assignable
> : public __is_move_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, typename _Up>
> struct __is_nt_assignable_impl
> : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_nothrow_assignable
> : public __and_<is_assignable<_Tp, _Up>,
> __is_nt_assignable_impl<_Tp, _Up>>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nt_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, true>
> : public is_nothrow_assignable<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_assignable
> : public __is_nt_copy_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_nt_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, true>
> : public is_nothrow_assignable<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_assignable
> : public __is_nt_move_assignable_impl<_Tp>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_trivially_constructible
> : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_default_constructible
> : public is_trivially_constructible<_Tp>::type
> { };
>
> struct __do_is_implicitly_default_constructible_impl
> {
> template <typename _Tp>
> static void __helper(const _Tp&);
>
> template <typename _Tp>
> static true_type __test(const _Tp&,
> decltype(__helper<const _Tp&>({}))* = 0);
>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_implicitly_default_constructible_impl
> : public __do_is_implicitly_default_constructible_impl
> {
> typedef decltype(__test(declval<_Tp>())) type;
> };
>
> template<typename _Tp>
> struct __is_implicitly_default_constructible_safe
> : public __is_implicitly_default_constructible_impl<_Tp>::type
> { };
>
> template <typename _Tp>
> struct __is_implicitly_default_constructible
> : public __and_<is_default_constructible<_Tp>,
> __is_implicitly_default_constructible_safe<_Tp>>
> { };
>
>
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_trivially_copy_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_copy_constructible_impl<_Tp, true>
> : public __and_<is_copy_constructible<_Tp>,
> integral_constant<bool,
> __is_trivially_constructible(_Tp, const _Tp&)>>
> { };
>
> template<typename _Tp>
> struct is_trivially_copy_constructible
> : public __is_trivially_copy_constructible_impl<_Tp>
> { };
>
>
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_trivially_move_constructible_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_move_constructible_impl<_Tp, true>
> : public __and_<is_move_constructible<_Tp>,
> integral_constant<bool,
> __is_trivially_constructible(_Tp, _Tp&&)>>
> { };
>
> template<typename _Tp>
> struct is_trivially_move_constructible
> : public __is_trivially_move_constructible_impl<_Tp>
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_trivially_assignable
> : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
> { };
>
>
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_trivially_copy_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_copy_assignable_impl<_Tp, true>
> : public __and_<is_copy_assignable<_Tp>,
> integral_constant<bool,
> __is_trivially_assignable(_Tp&, const _Tp&)>>
> { };
>
> template<typename _Tp>
> struct is_trivially_copy_assignable
> : public __is_trivially_copy_assignable_impl<_Tp>
> { };
>
>
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __is_trivially_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_trivially_move_assignable_impl<_Tp, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_trivially_move_assignable_impl<_Tp, true>
> : public __and_<is_move_assignable<_Tp>,
> integral_constant<bool,
> __is_trivially_assignable(_Tp&, _Tp&&)>>
> { };
>
> template<typename _Tp>
> struct is_trivially_move_assignable
> : public __is_trivially_move_assignable_impl<_Tp>
> { };
>
>
> template<typename _Tp>
> struct is_trivially_destructible
> : public __and_<is_destructible<_Tp>, integral_constant<bool,
> __has_trivial_destructor(_Tp)>>
> { };
>
>
>
> template<typename _Tp>
> struct has_virtual_destructor
> : public integral_constant<bool, __has_virtual_destructor(_Tp)>
> { };
>
>
>
>
>
> template<typename _Tp>
> struct alignment_of
> : public integral_constant<std::size_t, __alignof__(_Tp)> { };
>
>
> template<typename>
> struct rank
> : public integral_constant<std::size_t, 0> { };
>
> template<typename _Tp, std::size_t _Size>
> struct rank<_Tp[_Size]>
> : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
>
> template<typename _Tp>
> struct rank<_Tp[]>
> : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
>
>
> template<typename, unsigned _Uint>
> struct extent
> : public integral_constant<std::size_t, 0> { };
>
> template<typename _Tp, unsigned _Uint, std::size_t _Size>
> struct extent<_Tp[_Size], _Uint>
> : public integral_constant<std::size_t,
> _Uint == 0 ? _Size : extent<_Tp,
> _Uint - 1>::value>
> { };
>
> template<typename _Tp, unsigned _Uint>
> struct extent<_Tp[], _Uint>
> : public integral_constant<std::size_t,
> _Uint == 0 ? 0 : extent<_Tp,
> _Uint - 1>::value>
> { };
>
>
>
>
>
> template<typename, typename>
> struct is_same
> : public false_type { };
>
> template<typename _Tp>
> struct is_same<_Tp, _Tp>
> : public true_type { };
>
>
> template<typename _Base, typename _Derived>
> struct is_base_of
> : public integral_constant<bool, __is_base_of(_Base, _Derived)>
> { };
>
> template<typename _From, typename _To,
> bool = __or_<is_void<_From>, is_function<_To>,
> is_array<_To>>::value>
> struct __is_convertible_helper
> { typedef typename is_void<_To>::type type; };
>
> template<typename _From, typename _To>
> class __is_convertible_helper<_From, _To, false>
> {
> template<typename _To1>
> static void __test_aux(_To1);
>
> template<typename _From1, typename _To1,
> typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
> static true_type
> __test(int);
>
> template<typename, typename>
> static false_type
> __test(...);
>
> public:
> typedef decltype(__test<_From, _To>(0)) type;
> };
>
>
>
> template<typename _From, typename _To>
> struct is_convertible
> : public __is_convertible_helper<_From, _To>::type
> { };
>
>
>
>
>
> template<typename _Tp>
> struct remove_const
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_const<_Tp const>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_volatile
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_volatile<_Tp volatile>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_cv
> {
> typedef typename
> remove_const<typename remove_volatile<_Tp>::type>::type type;
> };
>
>
> template<typename _Tp>
> struct add_const
> { typedef _Tp const type; };
>
>
> template<typename _Tp>
> struct add_volatile
> { typedef _Tp volatile type; };
>
>
> template<typename _Tp>
> struct add_cv
> {
> typedef typename
> add_const<typename add_volatile<_Tp>::type>::type type;
> };
>
>
>
>
>
>
> template<typename _Tp>
> using remove_const_t = typename remove_const<_Tp>::type;
>
>
> template<typename _Tp>
> using remove_volatile_t = typename remove_volatile<_Tp>::type;
>
>
> template<typename _Tp>
> using remove_cv_t = typename remove_cv<_Tp>::type;
>
>
> template<typename _Tp>
> using add_const_t = typename add_const<_Tp>::type;
>
>
> template<typename _Tp>
> using add_volatile_t = typename add_volatile<_Tp>::type;
>
>
> template<typename _Tp>
> using add_cv_t = typename add_cv<_Tp>::type;
>
>
>
>
>
> template<typename _Tp>
> struct remove_reference
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&&>
> { typedef _Tp type; };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __add_lvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_lvalue_reference_helper<_Tp, true>
> { typedef _Tp& type; };
>
>
> template<typename _Tp>
> struct add_lvalue_reference
> : public __add_lvalue_reference_helper<_Tp>
> { };
>
> template<typename _Tp, bool = __is_referenceable<_Tp>::value>
> struct __add_rvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_rvalue_reference_helper<_Tp, true>
> { typedef _Tp&& type; };
>
>
> template<typename _Tp>
> struct add_rvalue_reference
> : public __add_rvalue_reference_helper<_Tp>
> { };
>
>
>
> template<typename _Tp>
> using remove_reference_t = typename remove_reference<_Tp>::type;
>
>
> template<typename _Tp>
> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
>
>
> template<typename _Tp>
> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
>
>
>
>
>
> template<typename _Unqualified, bool _IsConst, bool _IsVol>
> struct __cv_selector;
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, false>
> { typedef _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, true>
> { typedef volatile _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, false>
> { typedef const _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, true>
> { typedef const volatile _Unqualified __type; };
>
> template<typename _Qualified, typename _Unqualified,
> bool _IsConst = is_const<_Qualified>::value,
> bool _IsVol = is_volatile<_Qualified>::value>
> class __match_cv_qualifiers
> {
> typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
>
> public:
> typedef typename __match::__type __type;
> };
>
>
> template<typename _Tp>
> struct __make_unsigned
> { typedef _Tp __type; };
>
> template<>
> struct __make_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __make_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __make_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __make_unsigned<long long>
> { typedef unsigned long long __type; };
>
>
> template<>
> struct __make_unsigned<wchar_t> : __make_unsigned<int>
> { };
># 1607 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_unsigned_selector;
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, true, false>
> {
> typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
> typedef typename __unsignedt::__type __unsigned_type;
> typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
>
> public:
> typedef typename __cv_unsigned::__type __type;
> };
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, false, true>
> {
>
> typedef unsigned char __smallest;
> static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
> static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
> static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
> static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
> typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
> typedef typename __cond3::type __cond3_type;
> typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
> typedef typename __cond2::type __cond2_type;
> typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
> typedef typename __cond1::type __cond1_type;
>
> typedef typename conditional<__b0, __smallest, __cond1_type>::type
> __unsigned_type;
> typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
>
> public:
> typedef typename __cv_unsigned::__type __type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_unsigned
> { typedef typename __make_unsigned_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_unsigned<bool>;
>
>
>
> template<typename _Tp>
> struct __make_signed
> { typedef _Tp __type; };
>
> template<>
> struct __make_signed<char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned short>
> { typedef signed short __type; };
>
> template<>
> struct __make_signed<unsigned int>
> { typedef signed int __type; };
>
> template<>
> struct __make_signed<unsigned long>
> { typedef signed long __type; };
>
> template<>
> struct __make_signed<unsigned long long>
> { typedef signed long long __type; };
># 1696 "/usr/include/c++/8/type_traits" 3
> template<>
> struct __make_signed<char16_t> : __make_signed<uint_least16_t>
> { };
> template<>
> struct __make_signed<char32_t> : __make_signed<uint_least32_t>
> { };
># 1726 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_signed_selector;
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, true, false>
> {
> typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
> typedef typename __signedt::__type __signed_type;
> typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
>
> public:
> typedef typename __cv_signed::__type __type;
> };
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, false, true>
> {
> typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
>
> public:
> typedef typename __make_signed_selector<__unsigned_type>::__type __type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_signed
> { typedef typename __make_signed_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_signed<bool>;
>
>
>
> template<typename _Tp>
> using make_signed_t = typename make_signed<_Tp>::type;
>
>
> template<typename _Tp>
> using make_unsigned_t = typename make_unsigned<_Tp>::type;
>
>
>
>
>
> template<typename _Tp>
> struct remove_extent
> { typedef _Tp type; };
>
> template<typename _Tp, std::size_t _Size>
> struct remove_extent<_Tp[_Size]>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_extent<_Tp[]>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_all_extents
> { typedef _Tp type; };
>
> template<typename _Tp, std::size_t _Size>
> struct remove_all_extents<_Tp[_Size]>
> { typedef typename remove_all_extents<_Tp>::type type; };
>
> template<typename _Tp>
> struct remove_all_extents<_Tp[]>
> { typedef typename remove_all_extents<_Tp>::type type; };
>
>
>
> template<typename _Tp>
> using remove_extent_t = typename remove_extent<_Tp>::type;
>
>
> template<typename _Tp>
> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
>
>
>
>
> template<typename _Tp, typename>
> struct __remove_pointer_helper
> { typedef _Tp type; };
>
> template<typename _Tp, typename _Up>
> struct __remove_pointer_helper<_Tp, _Up*>
> { typedef _Up type; };
>
>
> template<typename _Tp>
> struct remove_pointer
> : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
> { };
>
>
> template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
> is_void<_Tp>>::value>
> struct __add_pointer_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_pointer_helper<_Tp, true>
> { typedef typename remove_reference<_Tp>::type* type; };
>
> template<typename _Tp>
> struct add_pointer
> : public __add_pointer_helper<_Tp>
> { };
>
>
>
> template<typename _Tp>
> using remove_pointer_t = typename remove_pointer<_Tp>::type;
>
>
> template<typename _Tp>
> using add_pointer_t = typename add_pointer<_Tp>::type;
>
>
> template<std::size_t _Len>
> struct __aligned_storage_msa
> {
> union __type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__)) { } __align;
> };
> };
># 1872 "/usr/include/c++/8/type_traits" 3
> template<std::size_t _Len, std::size_t _Align =
> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
> struct aligned_storage
> {
> union type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__((_Align)))) { } __align;
> };
> };
>
> template <typename... _Types>
> struct __strictest_alignment
> {
> static const size_t _S_alignment = 0;
> static const size_t _S_size = 0;
> };
>
> template <typename _Tp, typename... _Types>
> struct __strictest_alignment<_Tp, _Types...>
> {
> static const size_t _S_alignment =
> alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
> ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
> static const size_t _S_size =
> sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
> ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
> };
># 1911 "/usr/include/c++/8/type_traits" 3
> template <size_t _Len, typename... _Types>
> struct aligned_union
> {
> private:
> static_assert(sizeof...(_Types) != 0, "At least one type is required");
>
> using __strictest = __strictest_alignment<_Types...>;
> static const size_t _S_len = _Len > __strictest::_S_size
> ? _Len : __strictest::_S_size;
> public:
>
> static const size_t alignment_value = __strictest::_S_alignment;
>
> typedef typename aligned_storage<_S_len, alignment_value>::type type;
> };
>
> template <size_t _Len, typename... _Types>
> const size_t aligned_union<_Len, _Types...>::alignment_value;
>
>
>
> template<typename _Up,
> bool _IsArray = is_array<_Up>::value,
> bool _IsFunction = is_function<_Up>::value>
> struct __decay_selector;
>
>
> template<typename _Up>
> struct __decay_selector<_Up, false, false>
> { typedef typename remove_cv<_Up>::type __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, true, false>
> { typedef typename remove_extent<_Up>::type* __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, false, true>
> { typedef typename add_pointer<_Up>::type __type; };
>
>
> template<typename _Tp>
> class decay
> {
> typedef typename remove_reference<_Tp>::type __remove_type;
>
> public:
> typedef typename __decay_selector<__remove_type>::__type type;
> };
>
> template<typename _Tp>
> class reference_wrapper;
>
>
> template<typename _Tp>
> struct __strip_reference_wrapper
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp>
> struct __strip_reference_wrapper<reference_wrapper<_Tp> >
> {
> typedef _Tp& __type;
> };
>
> template<typename _Tp>
> struct __decay_and_strip
> {
> typedef typename __strip_reference_wrapper<
> typename decay<_Tp>::type>::__type __type;
> };
>
>
>
>
> template<bool, typename _Tp = void>
> struct enable_if
> { };
>
>
> template<typename _Tp>
> struct enable_if<true, _Tp>
> { typedef _Tp type; };
>
> template<typename... _Cond>
> using _Require = typename enable_if<__and_<_Cond...>::value>::type;
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct conditional
> { typedef _Iftrue type; };
>
>
> template<typename _Iftrue, typename _Iffalse>
> struct conditional<false, _Iftrue, _Iffalse>
> { typedef _Iffalse type; };
>
>
> template<typename... _Tp>
> struct common_type;
>
>
>
> struct __do_common_type_impl
> {
> template<typename _Tp, typename _Up>
> static __success_type<typename decay<decltype
> (true ? std::declval<_Tp>()
> : std::declval<_Up>())>::type> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _Tp, typename _Up>
> struct __common_type_impl
> : private __do_common_type_impl
> {
> typedef decltype(_S_test<_Tp, _Up>(0)) type;
> };
>
> struct __do_member_type_wrapper
> {
> template<typename _Tp>
> static __success_type<typename _Tp::type> _S_test(int);
>
> template<typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _Tp>
> struct __member_type_wrapper
> : private __do_member_type_wrapper
> {
> typedef decltype(_S_test<_Tp>(0)) type;
> };
>
> template<typename _CTp, typename... _Args>
> struct __expanded_common_type_wrapper
> {
> typedef common_type<typename _CTp::type, _Args...> type;
> };
>
> template<typename... _Args>
> struct __expanded_common_type_wrapper<__failure_type, _Args...>
> { typedef __failure_type type; };
>
> template<typename _Tp>
> struct common_type<_Tp>
> { typedef typename decay<_Tp>::type type; };
>
> template<typename _Tp, typename _Up>
> struct common_type<_Tp, _Up>
> : public __common_type_impl<_Tp, _Up>::type
> { };
>
> template<typename _Tp, typename _Up, typename... _Vp>
> struct common_type<_Tp, _Up, _Vp...>
> : public __expanded_common_type_wrapper<typename __member_type_wrapper<
> common_type<_Tp, _Up>>::type, _Vp...>::type
> { };
>
>
> template<typename _Tp>
> struct underlying_type
> {
> typedef __underlying_type(_Tp) type;
> };
>
> template<typename _Tp>
> struct __declval_protector
> {
> static const bool __stop = false;
> };
>
> template<typename _Tp>
> auto declval() noexcept -> decltype(__declval<_Tp>(0))
> {
> static_assert(__declval_protector<_Tp>::__stop,
> "declval() must not be used!");
> return __declval<_Tp>(0);
> }
>
>
> template<typename _Signature>
> class result_of;
>
>
>
>
>
> struct __invoke_memfun_ref { };
> struct __invoke_memfun_deref { };
> struct __invoke_memobj_ref { };
> struct __invoke_memobj_deref { };
> struct __invoke_other { };
>
>
> template<typename _Tp, typename _Tag>
> struct __result_of_success : __success_type<_Tp>
> { using __invoke_type = _Tag; };
>
>
> struct __result_of_memfun_ref_impl
> {
> template<typename _Fp, typename _Tp1, typename... _Args>
> static __result_of_success<decltype(
> (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
> ), __invoke_memfun_ref> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun_ref
> : private __result_of_memfun_ref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
> };
>
>
> struct __result_of_memfun_deref_impl
> {
> template<typename _Fp, typename _Tp1, typename... _Args>
> static __result_of_success<decltype(
> ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
> ), __invoke_memfun_deref> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun_deref
> : private __result_of_memfun_deref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
> };
>
>
> struct __result_of_memobj_ref_impl
> {
> template<typename _Fp, typename _Tp1>
> static __result_of_success<decltype(
> std::declval<_Tp1>().*std::declval<_Fp>()
> ), __invoke_memobj_ref> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj_ref
> : private __result_of_memobj_ref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
> };
>
>
> struct __result_of_memobj_deref_impl
> {
> template<typename _Fp, typename _Tp1>
> static __result_of_success<decltype(
> (*std::declval<_Tp1>()).*std::declval<_Fp>()
> ), __invoke_memobj_deref> _S_test(int);
>
> template<typename, typename>
> static __failure_type _S_test(...);
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj_deref
> : private __result_of_memobj_deref_impl
> {
> typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_memobj;
>
> template<typename _Res, typename _Class, typename _Arg>
> struct __result_of_memobj<_Res _Class::*, _Arg>
> {
> typedef typename remove_cv<typename remove_reference<
> _Arg>::type>::type _Argval;
> typedef _Res _Class::* _MemPtr;
> typedef typename conditional<__or_<is_same<_Argval, _Class>,
> is_base_of<_Class, _Argval>>::value,
> __result_of_memobj_ref<_MemPtr, _Arg>,
> __result_of_memobj_deref<_MemPtr, _Arg>
> >::type::type type;
> };
>
> template<typename _MemPtr, typename _Arg, typename... _Args>
> struct __result_of_memfun;
>
> template<typename _Res, typename _Class, typename _Arg, typename... _Args>
> struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
> {
> typedef typename remove_cv<typename remove_reference<
> _Arg>::type>::type _Argval;
> typedef _Res _Class::* _MemPtr;
> typedef typename conditional<__or_<is_same<_Argval, _Class>,
> is_base_of<_Class, _Argval>>::value,
> __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
> __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
> >::type::type type;
> };
>
>
>
>
>
>
> template<typename _Tp, typename _Up = typename decay<_Tp>::type>
> struct __inv_unwrap
> {
> using type = _Tp;
> };
>
> template<typename _Tp, typename _Up>
> struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
> {
> using type = _Up&;
> };
>
> template<bool, bool, typename _Functor, typename... _ArgTypes>
> struct __result_of_impl
> {
> typedef __failure_type type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct __result_of_impl<true, false, _MemPtr, _Arg>
> : public __result_of_memobj<typename decay<_MemPtr>::type,
> 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<typename decay<_MemPtr>::type,
> typename __inv_unwrap<_Arg>::type, _Args...>
> { };
>
>
> struct __result_of_other_impl
> {
> template<typename _Fn, typename... _Args>
> static __result_of_success<decltype(
> std::declval<_Fn>()(std::declval<_Args>()...)
> ), __invoke_other> _S_test(int);
>
> template<typename...>
> static __failure_type _S_test(...);
> };
>
> template<typename _Functor, typename... _ArgTypes>
> struct __result_of_impl<false, false, _Functor, _ArgTypes...>
> : private __result_of_other_impl
> {
> typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
> };
>
>
> template<typename _Functor, typename... _ArgTypes>
> struct __invoke_result
> : public __result_of_impl<
> is_member_object_pointer<
> typename remove_reference<_Functor>::type
> >::value,
> is_member_function_pointer<
> typename remove_reference<_Functor>::type
> >::value,
> _Functor, _ArgTypes...
> >::type
> { };
>
> template<typename _Functor, typename... _ArgTypes>
> struct result_of<_Functor(_ArgTypes...)>
> : public __invoke_result<_Functor, _ArgTypes...>
> { };
>
>
>
> template<size_t _Len, size_t _Align =
> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
> using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
>
> template <size_t _Len, typename... _Types>
> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
>
>
> template<typename _Tp>
> using decay_t = typename decay<_Tp>::type;
>
>
> template<bool _Cond, typename _Tp = void>
> using enable_if_t = typename enable_if<_Cond, _Tp>::type;
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
>
>
> template<typename... _Tp>
> using common_type_t = typename common_type<_Tp...>::type;
>
>
> template<typename _Tp>
> using underlying_type_t = typename underlying_type<_Tp>::type;
>
>
> template<typename _Tp>
> using result_of_t = typename result_of<_Tp>::type;
>
>
> template<typename...> using __void_t = void;
>
>
>
>
> template<typename...> using void_t = void;
>
>
>
> template<typename _Default, typename _AlwaysVoid,
> template<typename...> class _Op, typename... _Args>
> struct __detector
> {
> using value_t = false_type;
> using type = _Default;
> };
>
>
> template<typename _Default, template<typename...> class _Op,
> typename... _Args>
> struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
> {
> using value_t = true_type;
> using type = _Op<_Args...>;
> };
>
>
> template<typename _Default, template<typename...> class _Op,
> typename... _Args>
> using __detected_or = __detector<_Default, void, _Op, _Args...>;
>
>
> template<typename _Default, template<typename...> class _Op,
> typename... _Args>
> using __detected_or_t
> = typename __detected_or<_Default, _Op, _Args...>::type;
># 2382 "/usr/include/c++/8/type_traits" 3
> template <typename _Tp>
> struct __is_swappable;
>
> template <typename _Tp>
> struct __is_nothrow_swappable;
>
> template<typename... _Elements>
> class tuple;
>
> template<typename>
> struct __is_tuple_like_impl : false_type
> { };
>
> template<typename... _Tps>
> struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
> { };
>
>
> template<typename _Tp>
> struct __is_tuple_like
> : public __is_tuple_like_impl<typename remove_cv<
> typename remove_reference<_Tp>::type>::type>::type
> { };
>
> template<typename _Tp>
> inline
> typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
> is_move_constructible<_Tp>,
> is_move_assignable<_Tp>>::value>::type
> swap(_Tp&, _Tp&)
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value);
>
> template<typename _Tp, size_t _Nm>
> inline
> typename enable_if<__is_swappable<_Tp>::value>::type
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
> noexcept(__is_nothrow_swappable<_Tp>::value);
>
> namespace __swappable_details {
> using std::swap;
>
> struct __do_is_swappable_impl
> {
> template<typename _Tp, typename
> = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> struct __do_is_nothrow_swappable_impl
> {
> template<typename _Tp>
> static __bool_constant<
> noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> > __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> }
>
> template<typename _Tp>
> struct __is_swappable_impl
> : public __swappable_details::__do_is_swappable_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_nothrow_swappable_impl
> : public __swappable_details::__do_is_nothrow_swappable_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_swappable
> : public __is_swappable_impl<_Tp>::type
> { };
>
> template<typename _Tp>
> struct __is_nothrow_swappable
> : public __is_nothrow_swappable_impl<_Tp>::type
> { };
>
>
>
>
>
>
> template<typename _Tp>
> struct is_swappable
> : public __is_swappable_impl<_Tp>::type
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_swappable
> : public __is_nothrow_swappable_impl<_Tp>::type
> { };
>
>
>
> template<typename _Tp>
> inline constexpr bool is_swappable_v =
> is_swappable<_Tp>::value;
>
>
> template<typename _Tp>
> inline constexpr bool is_nothrow_swappable_v =
> is_nothrow_swappable<_Tp>::value;
>
>
> namespace __swappable_with_details {
> using std::swap;
>
> struct __do_is_swappable_with_impl
> {
> template<typename _Tp, typename _Up, typename
> = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
> typename
> = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
> static true_type __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> struct __do_is_nothrow_swappable_with_impl
> {
> template<typename _Tp, typename _Up>
> static __bool_constant<
> noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
> &&
> noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
> > __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> }
>
> template<typename _Tp, typename _Up>
> struct __is_swappable_with_impl
> : public __swappable_with_details::__do_is_swappable_with_impl
> {
> typedef decltype(__test<_Tp, _Up>(0)) type;
> };
>
>
> template<typename _Tp>
> struct __is_swappable_with_impl<_Tp&, _Tp&>
> : public __swappable_details::__do_is_swappable_impl
> {
> typedef decltype(__test<_Tp&>(0)) type;
> };
>
> template<typename _Tp, typename _Up>
> struct __is_nothrow_swappable_with_impl
> : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
> {
> typedef decltype(__test<_Tp, _Up>(0)) type;
> };
>
>
> template<typename _Tp>
> struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
> : public __swappable_details::__do_is_nothrow_swappable_impl
> {
> typedef decltype(__test<_Tp&>(0)) type;
> };
>
>
> template<typename _Tp, typename _Up>
> struct is_swappable_with
> : public __is_swappable_with_impl<_Tp, _Up>::type
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_nothrow_swappable_with
> : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
> { };
>
>
>
> template<typename _Tp, typename _Up>
> inline constexpr bool is_swappable_with_v =
> is_swappable_with<_Tp, _Up>::value;
>
>
> template<typename _Tp, typename _Up>
> inline constexpr bool is_nothrow_swappable_with_v =
> is_nothrow_swappable_with<_Tp, _Up>::value;
>
>
>
>
>
>
> template<typename _Result, typename _Ret, typename = void>
> struct __is_invocable_impl : false_type { };
>
> template<typename _Result, typename _Ret>
> struct __is_invocable_impl<_Result, _Ret, __void_t<typename _Result::type>>
> : __or_<is_void<_Ret>, is_convertible<typename _Result::type, _Ret>>::type
> { };
>
> 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
> { };
>
> struct __nonesuch {
> __nonesuch() = delete;
> ~__nonesuch() = delete;
> __nonesuch(__nonesuch const&) = delete;
> void operator=(__nonesuch const&) = delete;
> };
>
>
>
>
>
> template<typename _Functor, typename... _ArgTypes>
> struct invoke_result
> : public __invoke_result<_Functor, _ArgTypes...>
> { };
>
>
> template<typename _Fn, typename... _Args>
> using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
>
>
> template<typename _Fn, typename... _ArgTypes>
> struct is_invocable
> : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
> { };
>
>
> template<typename _Ret, typename _Fn, typename... _ArgTypes>
> struct is_invocable_r
> : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
> { };
>
>
> template<typename _Fn, typename... _ArgTypes>
> struct is_nothrow_invocable
> : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
> __call_is_nothrow_<_Fn, _ArgTypes...>>::type
> { };
>
> template<typename _Result, typename _Ret, typename = void>
> struct __is_nt_invocable_impl : false_type { };
>
> template<typename _Result, typename _Ret>
> struct __is_nt_invocable_impl<_Result, _Ret,
> __void_t<typename _Result::type>>
> : __or_<is_void<_Ret>,
> __and_<is_convertible<typename _Result::type, _Ret>,
> is_nothrow_constructible<_Ret, typename _Result::type>>>
> { };
>
>
> template<typename _Ret, typename _Fn, typename... _ArgTypes>
> struct is_nothrow_invocable_r
> : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
> __call_is_nothrow_<_Fn, _ArgTypes...>>::type
> { };
>
>
> template<typename _Fn, typename... _Args>
> inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
>
>
> template<typename _Fn, typename... _Args>
> inline constexpr bool is_nothrow_invocable_v
> = is_nothrow_invocable<_Fn, _Args...>::value;
>
>
> template<typename _Fn, typename... _Args>
> inline constexpr bool is_invocable_r_v
> = is_invocable_r<_Fn, _Args...>::value;
>
>
> template<typename _Fn, typename... _Args>
> inline constexpr bool is_nothrow_invocable_r_v
> = is_nothrow_invocable_r<_Fn, _Args...>::value;
>
>
>
>
>template <typename _Tp>
> inline constexpr bool is_void_v = is_void<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_integral_v = is_integral<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_array_v = is_array<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_lvalue_reference_v =
> is_lvalue_reference<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_rvalue_reference_v =
> is_rvalue_reference<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_member_object_pointer_v =
> is_member_object_pointer<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_member_function_pointer_v =
> is_member_function_pointer<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_enum_v = is_enum<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_union_v = is_union<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_class_v = is_class<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_function_v = is_function<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_reference_v = is_reference<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_object_v = is_object<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_compound_v = is_compound<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_const_v = is_const<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_copyable_v =
> is_trivially_copyable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_pod_v = is_pod<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_empty_v = is_empty<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_final_v = is_final<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_signed_v = is_signed<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
>template <typename _Tp, typename... _Args>
> inline constexpr bool is_constructible_v =
> is_constructible<_Tp, _Args...>::value;
>template <typename _Tp>
> inline constexpr bool is_default_constructible_v =
> is_default_constructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_copy_constructible_v =
> is_copy_constructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_move_constructible_v =
> is_move_constructible<_Tp>::value;
>template <typename _Tp, typename _Up>
> inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
>template <typename _Tp>
> inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
>template <typename _Tp, typename... _Args>
> inline constexpr bool is_trivially_constructible_v =
> is_trivially_constructible<_Tp, _Args...>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_default_constructible_v =
> is_trivially_default_constructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_copy_constructible_v =
> is_trivially_copy_constructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_move_constructible_v =
> is_trivially_move_constructible<_Tp>::value;
>template <typename _Tp, typename _Up>
> inline constexpr bool is_trivially_assignable_v =
> is_trivially_assignable<_Tp, _Up>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_copy_assignable_v =
> is_trivially_copy_assignable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_move_assignable_v =
> is_trivially_move_assignable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_trivially_destructible_v =
> is_trivially_destructible<_Tp>::value;
>template <typename _Tp, typename... _Args>
> inline constexpr bool is_nothrow_constructible_v =
> is_nothrow_constructible<_Tp, _Args...>::value;
>template <typename _Tp>
> inline constexpr bool is_nothrow_default_constructible_v =
> is_nothrow_default_constructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_nothrow_copy_constructible_v =
> is_nothrow_copy_constructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_nothrow_move_constructible_v =
> is_nothrow_move_constructible<_Tp>::value;
>template <typename _Tp, typename _Up>
> inline constexpr bool is_nothrow_assignable_v =
> is_nothrow_assignable<_Tp, _Up>::value;
>template <typename _Tp>
> inline constexpr bool is_nothrow_copy_assignable_v =
> is_nothrow_copy_assignable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_nothrow_move_assignable_v =
> is_nothrow_move_assignable<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool is_nothrow_destructible_v =
> is_nothrow_destructible<_Tp>::value;
>template <typename _Tp>
> inline constexpr bool has_virtual_destructor_v =
> has_virtual_destructor<_Tp>::value;
>template <typename _Tp>
> inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
>template <typename _Tp>
> inline constexpr size_t rank_v = rank<_Tp>::value;
>template <typename _Tp, unsigned _Idx = 0>
> inline constexpr size_t extent_v = extent<_Tp, _Idx>::value;
>template <typename _Tp, typename _Up>
> inline constexpr bool is_same_v = is_same<_Tp, _Up>::value;
>template <typename _Base, typename _Derived>
> inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
>template <typename _From, typename _To>
> inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
># 2900 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp>
> struct has_unique_object_representations
> : bool_constant<__has_unique_object_representations(
> remove_cv_t<remove_all_extents_t<_Tp>>
> )>
> { };
>
> template<typename _Tp>
> inline constexpr bool has_unique_object_representations_v
> = has_unique_object_representations<_Tp>::value;
># 2925 "/usr/include/c++/8/type_traits" 3
> template<typename _Tp>
> struct is_aggregate
> : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { };
>
>
> template<typename _Tp>
> inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
># 2947 "/usr/include/c++/8/type_traits" 3
>
>}
># 56 "/usr/include/c++/8/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 72 "/usr/include/c++/8/bits/move.h" 3
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type& __t) noexcept
> { return static_cast<_Tp&&>(__t); }
>
>
>
>
>
>
>
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
> {
> static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
> " substituting _Tp is an lvalue reference type");
> return static_cast<_Tp&&>(__t);
> }
>
>
>
>
>
>
> template<typename _Tp>
> constexpr typename std::remove_reference<_Tp>::type&&
> move(_Tp&& __t) noexcept
> { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
>
>
> template<typename _Tp>
> struct __move_if_noexcept_cond
> : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
> is_copy_constructible<_Tp>>::type { };
># 116 "/usr/include/c++/8/bits/move.h" 3
> template<typename _Tp>
> constexpr typename
> conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
> move_if_noexcept(_Tp& __x) noexcept
> { return std::move(__x); }
># 136 "/usr/include/c++/8/bits/move.h" 3
> template<typename _Tp>
> inline constexpr _Tp*
> addressof(_Tp& __r) noexcept
> { return std::__addressof(__r); }
>
>
>
> template<typename _Tp>
> const _Tp* addressof(const _Tp&&) = delete;
>
>
> template <typename _Tp, typename _Up = _Tp>
> inline _Tp
> __exchange(_Tp& __obj, _Up&& __new_val)
> {
> _Tp __old_val = std::move(__obj);
> __obj = std::forward<_Up>(__new_val);
> return __old_val;
> }
># 176 "/usr/include/c++/8/bits/move.h" 3
> template<typename _Tp>
> inline
>
> typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
> is_move_constructible<_Tp>,
> is_move_assignable<_Tp>>::value>::type
> swap(_Tp& __a, _Tp& __b)
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value)
>
>
>
>
> {
>
> 
>
> _Tp __tmp = std::move(__a);
> __a = std::move(__b);
> __b = std::move(__tmp);
> }
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline
>
> typename enable_if<__is_swappable<_Tp>::value>::type
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
> noexcept(__is_nothrow_swappable<_Tp>::value)
>
>
>
>
> {
> for (size_t __n = 0; __n < _Nm; ++__n)
> swap(__a[__n], __b[__n]);
> }
>
>
>
>}
># 41 "/usr/include/c++/8/bits/nested_exception.h" 2 3
>
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class nested_exception
> {
> exception_ptr _M_ptr;
>
> public:
> nested_exception() noexcept : _M_ptr(current_exception()) { }
>
> nested_exception(const nested_exception&) noexcept = default;
>
> nested_exception& operator=(const nested_exception&) noexcept = default;
>
> virtual ~nested_exception() noexcept;
>
> [[noreturn]]
> void
> rethrow_nested() const
> {
> if (_M_ptr)
> rethrow_exception(_M_ptr);
> std::terminate();
> }
>
> exception_ptr
> nested_ptr() const noexcept
> { return _M_ptr; }
> };
>
> template<typename _Except>
> struct _Nested_exception : public _Except, public nested_exception
> {
> explicit _Nested_exception(const _Except& __ex)
> : _Except(__ex)
> { }
>
> explicit _Nested_exception(_Except&& __ex)
> : _Except(static_cast<_Except&&>(__ex))
> { }
> };
>
>
>
>
> template<typename _Tp>
> [[noreturn]]
> inline void
> __throw_with_nested_impl(_Tp&& __t, true_type)
> {
> using _Up = typename remove_reference<_Tp>::type;
> throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
> }
>
> template<typename _Tp>
> [[noreturn]]
> inline void
> __throw_with_nested_impl(_Tp&& __t, false_type)
> { throw std::forward<_Tp>(__t); }
>
>
>
> template<typename _Tp>
> [[noreturn]]
> inline void
> throw_with_nested(_Tp&& __t)
> {
> using _Up = typename decay<_Tp>::type;
> using _CopyConstructible
> = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
> static_assert(_CopyConstructible::value,
> "throw_with_nested argument must be CopyConstructible");
> using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
> __not_<is_base_of<nested_exception, _Up>>>;
> std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
> }
>
>
> template<typename _Tp>
> using __rethrow_if_nested_cond = typename enable_if<
> __and_<is_polymorphic<_Tp>,
> __or_<__not_<is_base_of<nested_exception, _Tp>>,
> is_convertible<_Tp*, nested_exception*>>>::value
> >::type;
>
>
> template<typename _Ex>
> inline __rethrow_if_nested_cond<_Ex>
> __rethrow_if_nested_impl(const _Ex* __ptr)
> {
> if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
> __ne_ptr->rethrow_nested();
> }
>
>
> inline void
> __rethrow_if_nested_impl(const void*)
> { }
>
>
> template<typename _Ex>
> inline void
> rethrow_if_nested(const _Ex& __ex)
> { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
>
>
>}
>
>}
>
>
>
>#pragma GCC visibility pop
># 145 "/usr/include/c++/8/exception" 2 3
># 40 "/usr/include/c++/8/ios" 2 3
># 1 "/usr/include/c++/8/bits/char_traits.h" 1 3
># 37 "/usr/include/c++/8/bits/char_traits.h" 3
> 
># 38 "/usr/include/c++/8/bits/char_traits.h" 3
>
># 1 "/usr/include/c++/8/bits/stl_algobase.h" 1 3
># 60 "/usr/include/c++/8/bits/stl_algobase.h" 3
># 1 "/usr/include/c++/8/bits/functexcept.h" 1 3
># 42 "/usr/include/c++/8/bits/functexcept.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> void
> __throw_bad_exception(void) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_alloc(void) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_cast(void) __attribute__((__noreturn__));
>
> void
> __throw_bad_typeid(void) __attribute__((__noreturn__));
>
>
> void
> __throw_logic_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_domain_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_invalid_argument(const char*) __attribute__((__noreturn__));
>
> void
> __throw_length_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_out_of_range(const char*) __attribute__((__noreturn__));
>
> void
> __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
> __attribute__((__format__(__gnu_printf__, 1, 2)));
>
> void
> __throw_runtime_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_range_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_overflow_error(const char*) __attribute__((__noreturn__));
>
> void
> __throw_underflow_error(const char*) __attribute__((__noreturn__));
>
>
> void
> __throw_ios_failure(const char*) __attribute__((__noreturn__));
>
> void
> __throw_system_error(int) __attribute__((__noreturn__));
>
> void
> __throw_future_error(int) __attribute__((__noreturn__));
>
>
> void
> __throw_bad_function_call() __attribute__((__noreturn__));
>
>
>}
># 61 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/bits/cpp_type_traits.h" 1 3
># 35 "/usr/include/c++/8/bits/cpp_type_traits.h" 3
> 
># 36 "/usr/include/c++/8/bits/cpp_type_traits.h" 3
># 67 "/usr/include/c++/8/bits/cpp_type_traits.h" 3
>extern "C++" {
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> struct __true_type { };
> struct __false_type { };
>
> template<bool>
> struct __truth_type
> { typedef __false_type __type; };
>
> template<>
> struct __truth_type<true>
> { typedef __true_type __type; };
>
>
>
> template<class _Sp, class _Tp>
> struct __traitor
> {
> enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
> typedef typename __truth_type<__value>::__type __type;
> };
>
>
> template<typename, typename>
> struct __are_same
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __are_same<_Tp, _Tp>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename _Tp>
> struct __is_void
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_void<void>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_integer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
>
>
>
> template<>
> struct __is_integer<bool>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
> template<>
> struct __is_integer<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;
> };
># 278 "/usr/include/c++/8/bits/cpp_type_traits.h" 3
> template<typename _Tp>
> struct __is_floating
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
> template<>
> struct __is_floating<float>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<long double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_pointer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __is_pointer<_Tp*>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_arithmetic
> : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_scalar
> : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_char
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_char<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_char<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename _Tp>
> struct __is_byte
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_byte<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_byte<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_byte<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_move_iterator
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
>
> template<typename _Iterator>
> inline _Iterator
> __miter_base(_Iterator __it)
> { return __it; }
>
>
>}
>}
># 62 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/ext/type_traits.h" 1 3
># 32 "/usr/include/c++/8/ext/type_traits.h" 3
> 
># 33 "/usr/include/c++/8/ext/type_traits.h" 3
>
>
>
>
>extern "C++" {
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<bool, typename>
> struct __enable_if
> { };
>
> template<typename _Tp>
> struct __enable_if<true, _Tp>
> { typedef _Tp __type; };
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct __conditional_type
> { typedef _Iftrue __type; };
>
> template<typename _Iftrue, typename _Iffalse>
> struct __conditional_type<false, _Iftrue, _Iffalse>
> { typedef _Iffalse __type; };
>
>
>
> template<typename _Tp>
> struct __add_unsigned
> {
> private:
> typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
> public:
> typedef typename __if_type::__type __type;
> };
>
> template<>
> struct __add_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __add_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __add_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __add_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __add_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __add_unsigned<long long>
> { typedef unsigned long long __type; };
>
>
> template<>
> struct __add_unsigned<bool>;
>
> template<>
> struct __add_unsigned<wchar_t>;
>
>
>
> template<typename _Tp>
> struct __remove_unsigned
> {
> private:
> typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
> public:
> typedef typename __if_type::__type __type;
> };
>
> template<>
> struct __remove_unsigned<char>
> { typedef signed char __type; };
>
> template<>
> struct __remove_unsigned<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __remove_unsigned<unsigned short>
> { typedef short __type; };
>
> template<>
> struct __remove_unsigned<unsigned int>
> { typedef int __type; };
>
> template<>
> struct __remove_unsigned<unsigned long>
> { typedef long __type; };
>
> template<>
> struct __remove_unsigned<unsigned long long>
> { typedef long long __type; };
>
>
> template<>
> struct __remove_unsigned<bool>;
>
> template<>
> struct __remove_unsigned<wchar_t>;
>
>
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type* __ptr)
> { return __ptr == 0; }
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type)
> { return false; }
>
>
> inline bool
> __is_null_pointer(std::nullptr_t)
> { return true; }
>
>
>
> template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
> struct __promote
> { typedef double __type; };
>
>
>
>
> template<typename _Tp>
> struct __promote<_Tp, false>
> { };
>
> template<>
> struct __promote<long double>
> { typedef long double __type; };
>
> template<>
> struct __promote<double>
> { typedef double __type; };
>
> template<>
> struct __promote<float>
> { typedef float __type; };
>
> template<typename _Tp, typename _Up,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type>
> struct __promote_2
> {
> typedef __typeof__(_Tp2() + _Up2()) __type;
> };
>
> template<typename _Tp, typename _Up, typename _Vp,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type,
> typename _Vp2 = typename __promote<_Vp>::__type>
> struct __promote_3
> {
> typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
> };
>
> template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type,
> typename _Vp2 = typename __promote<_Vp>::__type,
> typename _Wp2 = typename __promote<_Wp>::__type>
> struct __promote_4
> {
> typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
> };
>
>
>}
>}
># 63 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/ext/numeric_traits.h" 1 3
># 32 "/usr/include/c++/8/ext/numeric_traits.h" 3
> 
># 33 "/usr/include/c++/8/ext/numeric_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 54 "/usr/include/c++/8/ext/numeric_traits.h" 3
> template<typename _Value>
> struct __numeric_traits_integer
> {
>
> static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
> static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
>
>
>
> static const bool __is_signed = ((_Value)(-1) < 0);
> static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
> };
>
> template<typename _Value>
> const _Value __numeric_traits_integer<_Value>::__min;
>
> template<typename _Value>
> const _Value __numeric_traits_integer<_Value>::__max;
>
> template<typename _Value>
> const bool __numeric_traits_integer<_Value>::__is_signed;
>
> template<typename _Value>
> const int __numeric_traits_integer<_Value>::__digits;
># 99 "/usr/include/c++/8/ext/numeric_traits.h" 3
> template<typename _Value>
> struct __numeric_traits_floating
> {
>
> static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
>
>
> static const bool __is_signed = true;
> static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
> static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
> };
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__max_digits10;
>
> template<typename _Value>
> const bool __numeric_traits_floating<_Value>::__is_signed;
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__digits10;
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__max_exponent10;
>
> template<typename _Value>
> struct __numeric_traits
> : public __conditional_type<std::__is_integer<_Value>::__value,
> __numeric_traits_integer<_Value>,
> __numeric_traits_floating<_Value> >::__type
> { };
>
>
>}
># 64 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/bits/stl_pair.h" 1 3
># 65 "/usr/include/c++/8/bits/stl_pair.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 76 "/usr/include/c++/8/bits/stl_pair.h" 3
> struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
>
>
> inline constexpr piecewise_construct_t piecewise_construct =
> piecewise_construct_t();
>
>
> template<typename...>
> class tuple;
>
> template<std::size_t...>
> struct _Index_tuple;
>
>
>
>
>
>
> template <bool, typename _T1, typename _T2>
> struct _PCC
> {
> template <typename _U1, typename _U2>
> static constexpr bool _ConstructiblePair()
> {
> return __and_<is_constructible<_T1, const _U1&>,
> is_constructible<_T2, const _U2&>>::value;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyConvertiblePair()
> {
> return __and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _MoveConstructiblePair()
> {
> return __and_<is_constructible<_T1, _U1&&>,
> is_constructible<_T2, _U2&&>>::value;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyMoveConvertiblePair()
> {
> return __and_<is_convertible<_U1&&, _T1>,
> is_convertible<_U2&&, _T2>>::value;
> }
>
> template <bool __implicit, typename _U1, typename _U2>
> static constexpr bool _CopyMovePair()
> {
> using __do_converts = __and_<is_convertible<const _U1&, _T1>,
> is_convertible<_U2&&, _T2>>;
> using __converts = typename conditional<__implicit,
> __do_converts,
> __not_<__do_converts>>::type;
> return __and_<is_constructible<_T1, const _U1&>,
> is_constructible<_T2, _U2&&>,
> __converts
> >::value;
> }
>
> template <bool __implicit, typename _U1, typename _U2>
> static constexpr bool _MoveCopyPair()
> {
> using __do_converts = __and_<is_convertible<_U1&&, _T1>,
> is_convertible<const _U2&, _T2>>;
> using __converts = typename conditional<__implicit,
> __do_converts,
> __not_<__do_converts>>::type;
> return __and_<is_constructible<_T1, _U1&&>,
> is_constructible<_T2, const _U2&&>,
> __converts
> >::value;
> }
> };
>
> template <typename _T1, typename _T2>
> struct _PCC<false, _T1, _T2>
> {
> template <typename _U1, typename _U2>
> static constexpr bool _ConstructiblePair()
> {
> return false;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyConvertiblePair()
> {
> return false;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _MoveConstructiblePair()
> {
> return false;
> }
>
> template <typename _U1, typename _U2>
> static constexpr bool _ImplicitlyMoveConvertiblePair()
> {
> return false;
> }
> };
>
>
>
>
> struct __nonesuch_no_braces : std::__nonesuch {
> explicit __nonesuch_no_braces(const __nonesuch&) = delete;
> };
># 197 "/usr/include/c++/8/bits/stl_pair.h" 3
> template<typename _T1, typename _T2>
> struct pair
> {
> typedef _T1 first_type;
> typedef _T2 second_type;
>
> _T1 first;
> _T2 second;
>
>
>
>
>
>
> template <typename _U1 = _T1,
> typename _U2 = _T2,
> typename enable_if<__and_<
> __is_implicitly_default_constructible<_U1>,
> __is_implicitly_default_constructible<_U2>>
> ::value, bool>::type = true>
>
> constexpr pair()
> : first(), second() { }
>
>
> template <typename _U1 = _T1,
> typename _U2 = _T2,
> typename enable_if<__and_<
> is_default_constructible<_U1>,
> is_default_constructible<_U2>,
> __not_<
> __and_<__is_implicitly_default_constructible<_U1>,
> __is_implicitly_default_constructible<_U2>>>>
> ::value, bool>::type = false>
> explicit constexpr pair()
> : first(), second() { }
># 241 "/usr/include/c++/8/bits/stl_pair.h" 3
> using _PCCP = _PCC<true, _T1, _T2>;
>
> template<typename _U1 = _T1, typename _U2=_T2, typename
> enable_if<_PCCP::template
> _ConstructiblePair<_U1, _U2>()
> && _PCCP::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
>
> template<typename _U1 = _T1, typename _U2=_T2, typename
> enable_if<_PCCP::template
> _ConstructiblePair<_U1, _U2>()
> && !_PCCP::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
># 269 "/usr/include/c++/8/bits/stl_pair.h" 3
> template <typename _U1, typename _U2>
> using _PCCFP = _PCC<!is_same<_T1, _U1>::value
> || !is_same<_T2, _U2>::value,
> _T1, _T2>;
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _ConstructiblePair<_U1, _U2>()
> && _PCCFP<_U1, _U2>::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _ConstructiblePair<_U1, _U2>()
> && !_PCCFP<_U1, _U2>::template
> _ImplicitlyConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
>
> constexpr pair(const pair&) = default;
> constexpr pair(pair&&) = default;
>
>
> template<typename _U1, typename
> enable_if<_PCCP::template
> _MoveCopyPair<true, _U1, _T2>(),
> bool>::type=true>
> constexpr pair(_U1&& __x, const _T2& __y)
> : first(std::forward<_U1>(__x)), second(__y) { }
>
> template<typename _U1, typename
> enable_if<_PCCP::template
> _MoveCopyPair<false, _U1, _T2>(),
> bool>::type=false>
> explicit constexpr pair(_U1&& __x, const _T2& __y)
> : first(std::forward<_U1>(__x)), second(__y) { }
>
> template<typename _U2, typename
> enable_if<_PCCP::template
> _CopyMovePair<true, _T1, _U2>(),
> bool>::type=true>
> constexpr pair(const _T1& __x, _U2&& __y)
> : first(__x), second(std::forward<_U2>(__y)) { }
>
> template<typename _U2, typename
> enable_if<_PCCP::template
> _CopyMovePair<false, _T1, _U2>(),
> bool>::type=false>
> explicit pair(const _T1& __x, _U2&& __y)
> : first(__x), second(std::forward<_U2>(__y)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCP::template
> _MoveConstructiblePair<_U1, _U2>()
> && _PCCP::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(_U1&& __x, _U2&& __y)
> : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCP::template
> _MoveConstructiblePair<_U1, _U2>()
> && !_PCCP::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(_U1&& __x, _U2&& __y)
> : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
>
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _MoveConstructiblePair<_U1, _U2>()
> && _PCCFP<_U1, _U2>::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=true>
> constexpr pair(pair<_U1, _U2>&& __p)
> : first(std::forward<_U1>(__p.first)),
> second(std::forward<_U2>(__p.second)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_PCCFP<_U1, _U2>::template
> _MoveConstructiblePair<_U1, _U2>()
> && !_PCCFP<_U1, _U2>::template
> _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
> bool>::type=false>
> explicit constexpr pair(pair<_U1, _U2>&& __p)
> : first(std::forward<_U1>(__p.first)),
> second(std::forward<_U2>(__p.second)) { }
>
> template<typename... _Args1, typename... _Args2>
> pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
>
> pair&
> operator=(typename conditional<
> __and_<is_copy_assignable<_T1>,
> is_copy_assignable<_T2>>::value,
> const pair&, const __nonesuch_no_braces&>::type __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> pair&
> operator=(typename conditional<
> __not_<__and_<is_copy_assignable<_T1>,
> is_copy_assignable<_T2>>>::value,
> const pair&, const __nonesuch_no_braces&>::type __p) = delete;
>
> pair&
> operator=(typename conditional<
> __and_<is_move_assignable<_T1>,
> is_move_assignable<_T2>>::value,
> pair&&, __nonesuch_no_braces&&>::type __p)
> noexcept(__and_<is_nothrow_move_assignable<_T1>,
> is_nothrow_move_assignable<_T2>>::value)
> {
> first = std::forward<first_type>(__p.first);
> second = std::forward<second_type>(__p.second);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
> is_assignable<_T2&, const _U2&>>::value,
> pair&>::type
> operator=(const pair<_U1, _U2>& __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
> is_assignable<_T2&, _U2&&>>::value,
> pair&>::type
> operator=(pair<_U1, _U2>&& __p)
> {
> first = std::forward<_U1>(__p.first);
> second = std::forward<_U2>(__p.second);
> return *this;
> }
>
> void
> swap(pair& __p)
> noexcept(__and_<__is_nothrow_swappable<_T1>,
> __is_nothrow_swappable<_T2>>::value)
> {
> using std::swap;
> swap(first, __p.first);
> swap(second, __p.second);
> }
>
> private:
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
> pair(tuple<_Args1...>&, tuple<_Args2...>&,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
>
> };
>
>
> template<typename _T1, typename _T2> pair(_T1, _T2) -> pair<_T1, _T2>;
>
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first == __y.first && __x.second == __y.second; }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first < __y.first
> || (!(__y.first < __x.first) && __x.second < __y.second); }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x == __y); }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __y < __x; }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__y < __x); }
>
>
> template<typename _T1, typename _T2>
> inline constexpr bool
> operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x < __y); }
>
>
>
>
>
> template<typename _T1, typename _T2>
> inline
>
>
> typename enable_if<__and_<__is_swappable<_T1>,
> __is_swappable<_T2>>::value>::type
>
>
>
> swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
> template<typename _T1, typename _T2>
> typename enable_if<!__and_<__is_swappable<_T1>,
> __is_swappable<_T2>>::value>::type
> swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
># 516 "/usr/include/c++/8/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));
> }
># 535 "/usr/include/c++/8/bits/stl_pair.h" 3
>
>}
># 65 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 1 3
># 62 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 3
> 
># 63 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 89 "/usr/include/c++/8/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 { };
># 116 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 3
> template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
> typename _Pointer = _Tp*, typename _Reference = _Tp&>
> struct iterator
> {
>
> typedef _Category iterator_category;
>
> typedef _Tp value_type;
>
> typedef _Distance difference_type;
>
> typedef _Pointer pointer;
>
> typedef _Reference reference;
> };
># 143 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 3
> template<typename _Iterator, typename = __void_t<>>
> struct __iterator_traits { };
>
> template<typename _Iterator>
> struct __iterator_traits<_Iterator,
> __void_t<typename _Iterator::iterator_category,
> typename _Iterator::value_type,
> typename _Iterator::difference_type,
> typename _Iterator::pointer,
> typename _Iterator::reference>>
> {
> typedef typename _Iterator::iterator_category iterator_category;
> typedef typename _Iterator::value_type value_type;
> typedef typename _Iterator::difference_type difference_type;
> typedef typename _Iterator::pointer pointer;
> typedef typename _Iterator::reference reference;
> };
>
> template<typename _Iterator>
> struct iterator_traits
> : public __iterator_traits<_Iterator> { };
># 177 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 3
> template<typename _Tp>
> struct iterator_traits<_Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef _Tp& reference;
> };
>
>
> template<typename _Tp>
> struct iterator_traits<const _Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
> };
>
>
>
>
>
> template<typename _Iter>
> inline constexpr
> typename iterator_traits<_Iter>::iterator_category
> __iterator_category(const _Iter&)
> { return typename iterator_traits<_Iter>::iterator_category(); }
># 231 "/usr/include/c++/8/bits/stl_iterator_base_types.h" 3
> template<typename _InIter>
> using _RequireInputIter = typename
> enable_if<is_convertible<typename
> iterator_traits<_InIter>::iterator_category,
> input_iterator_tag>::value>::type;
>
>
>
>}
># 66 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/bits/stl_iterator_base_funcs.h" 1 3
># 62 "/usr/include/c++/8/bits/stl_iterator_base_funcs.h" 3
> 
># 63 "/usr/include/c++/8/bits/stl_iterator_base_funcs.h" 3
>
>
># 1 "/usr/include/c++/8/debug/assertions.h" 1 3
># 66 "/usr/include/c++/8/bits/stl_iterator_base_funcs.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template <typename> struct _List_iterator;
> template <typename> struct _List_const_iterator;
>
>
> template<typename _InputIterator>
> inline constexpr
> typename iterator_traits<_InputIterator>::difference_type
> __distance(_InputIterator __first, _InputIterator __last,
> input_iterator_tag)
> {
>
> 
>
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> while (__first != __last)
> {
> ++__first;
> ++__n;
> }
> return __n;
> }
>
> template<typename _RandomAccessIterator>
> inline constexpr
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
> return __last - __first;
> }
>
>
>
> template<typename _Tp>
> ptrdiff_t
> __distance(std::_List_iterator<_Tp>,
> std::_List_iterator<_Tp>,
> input_iterator_tag);
>
> template<typename _Tp>
> ptrdiff_t
> __distance(std::_List_const_iterator<_Tp>,
> std::_List_const_iterator<_Tp>,
> input_iterator_tag);
># 135 "/usr/include/c++/8/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator>
> inline constexpr
> typename iterator_traits<_InputIterator>::difference_type
> distance(_InputIterator __first, _InputIterator __last)
> {
>
> return std::__distance(__first, __last,
> std::__iterator_category(__first));
> }
>
> template<typename _InputIterator, typename _Distance>
> inline constexpr void
> __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
> {
>
> 
> ;
> while (__n--)
> ++__i;
> }
>
> template<typename _BidirectionalIterator, typename _Distance>
> inline constexpr void
> __advance(_BidirectionalIterator& __i, _Distance __n,
> bidirectional_iterator_tag)
> {
>
> 
>
> if (__n > 0)
> while (__n--)
> ++__i;
> else
> while (__n++)
> --__i;
> }
>
> template<typename _RandomAccessIterator, typename _Distance>
> inline constexpr void
> __advance(_RandomAccessIterator& __i, _Distance __n,
> random_access_iterator_tag)
> {
>
> 
>
> if (__builtin_constant_p(__n) && __n == 1)
> ++__i;
> else if (__builtin_constant_p(__n) && __n == -1)
> --__i;
> else
> __i += __n;
> }
># 200 "/usr/include/c++/8/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator, typename _Distance>
> inline constexpr void
> advance(_InputIterator& __i, _Distance __n)
> {
>
> typename iterator_traits<_InputIterator>::difference_type __d = __n;
> std::__advance(__i, __d, std::__iterator_category(__i));
> }
>
>
>
> template<typename _InputIterator>
> inline constexpr _InputIterator
> next(_InputIterator __x, typename
> iterator_traits<_InputIterator>::difference_type __n = 1)
> {
>
> 
> std::advance(__x, __n);
> return __x;
> }
>
> template<typename _BidirectionalIterator>
> inline constexpr _BidirectionalIterator
> prev(_BidirectionalIterator __x, typename
> iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
> {
>
> 
>
> std::advance(__x, -__n);
> return __x;
> }
>
>
>
>
>}
># 67 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
># 1 "/usr/include/c++/8/bits/stl_iterator.h" 1 3
># 66 "/usr/include/c++/8/bits/stl_iterator.h" 3
># 1 "/usr/include/c++/8/bits/ptr_traits.h" 1 3
># 37 "/usr/include/c++/8/bits/ptr_traits.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> class __undefined;
>
>
> template<typename _Tp>
> struct __get_first_arg
> { using type = __undefined; };
>
> template<template<typename, typename...> class _Template, typename _Tp,
> typename... _Types>
> struct __get_first_arg<_Template<_Tp, _Types...>>
> { using type = _Tp; };
>
> template<typename _Tp>
> using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
>
>
> template<typename _Tp, typename _Up>
> struct __replace_first_arg
> { };
>
> template<template<typename, typename...> class _Template, typename _Up,
> typename _Tp, typename... _Types>
> struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
> { using type = _Template<_Up, _Types...>; };
>
> template<typename _Tp, typename _Up>
> using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
>
> template<typename _Tp>
> using __make_not_void
> = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
>
>
>
>
>
> template<typename _Ptr>
> struct pointer_traits
> {
> private:
> template<typename _Tp>
> using __element_type = typename _Tp::element_type;
>
> template<typename _Tp>
> using __difference_type = typename _Tp::difference_type;
>
> template<typename _Tp, typename _Up, typename = void>
> struct __rebind : __replace_first_arg<_Tp, _Up> { };
>
> template<typename _Tp, typename _Up>
> struct __rebind<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>>>
> { using type = typename _Tp::template rebind<_Up>; };
>
> public:
>
> using pointer = _Ptr;
>
>
> using element_type
> = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>;
>
>
> using difference_type
> = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
>
>
> template<typename _Up>
> using rebind = typename __rebind<_Ptr, _Up>::type;
>
> static _Ptr
> pointer_to(__make_not_void<element_type>& __e)
> { return _Ptr::pointer_to(__e); }
>
> static_assert(!is_same<element_type, __undefined>::value,
> "pointer type defines element_type or is like SomePointer<T, Args>");
> };
>
>
>
>
>
> template<typename _Tp>
> struct pointer_traits<_Tp*>
> {
>
> typedef _Tp* pointer;
>
> typedef _Tp element_type;
>
> typedef ptrdiff_t difference_type;
>
> template<typename _Up>
> using rebind = _Up*;
>
>
>
>
>
>
> static pointer
> pointer_to(__make_not_void<element_type>& __r) noexcept
> { return std::addressof(__r); }
> };
>
>
> template<typename _Ptr, typename _Tp>
> using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
>
> template<typename _Tp>
> constexpr _Tp*
> __to_address(_Tp* __ptr) noexcept
> {
> static_assert(!std::is_function<_Tp>::value, "not a function pointer");
> return __ptr;
> }
>
>
> template<typename _Ptr>
> constexpr typename std::pointer_traits<_Ptr>::element_type*
> __to_address(const _Ptr& __ptr)
> { return std::__to_address(__ptr.operator->()); }
># 198 "/usr/include/c++/8/bits/ptr_traits.h" 3
>
>}
># 67 "/usr/include/c++/8/bits/stl_iterator.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 100 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class reverse_iterator
> : public iterator<typename iterator_traits<_Iterator>::iterator_category,
> typename iterator_traits<_Iterator>::value_type,
> typename iterator_traits<_Iterator>::difference_type,
> typename iterator_traits<_Iterator>::pointer,
> typename iterator_traits<_Iterator>::reference>
> {
> protected:
> _Iterator current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::difference_type difference_type;
> typedef typename __traits_type::pointer pointer;
> typedef typename __traits_type::reference reference;
>
>
>
>
>
>
>
> constexpr
> reverse_iterator() : current() { }
>
>
>
>
> explicit constexpr
> reverse_iterator(iterator_type __x) : current(__x) { }
>
>
>
>
> constexpr
> reverse_iterator(const reverse_iterator& __x)
> : current(__x.current) { }
>
>
>
>
>
> template<typename _Iter>
> constexpr
> reverse_iterator(const reverse_iterator<_Iter>& __x)
> : current(__x.base()) { }
>
>
>
>
> constexpr iterator_type
> base() const
> { return current; }
># 167 "/usr/include/c++/8/bits/stl_iterator.h" 3
> constexpr reference
> operator*() const
> {
> _Iterator __tmp = current;
> return *--__tmp;
> }
>
>
>
>
>
>
> constexpr pointer
> operator->() const
> { return &(operator*()); }
>
>
>
>
>
>
> constexpr reverse_iterator&
> operator++()
> {
> --current;
> return *this;
> }
>
>
>
>
>
>
> constexpr reverse_iterator
> operator++(int)
> {
> reverse_iterator __tmp = *this;
> --current;
> return __tmp;
> }
>
>
>
>
>
>
> constexpr reverse_iterator&
> operator--()
> {
> ++current;
> return *this;
> }
>
>
>
>
>
>
> constexpr reverse_iterator
> operator--(int)
> {
> reverse_iterator __tmp = *this;
> ++current;
> return __tmp;
> }
>
>
>
>
>
>
> constexpr reverse_iterator
> operator+(difference_type __n) const
> { return reverse_iterator(current - __n); }
>
>
>
>
>
>
>
> constexpr reverse_iterator&
> operator+=(difference_type __n)
> {
> current -= __n;
> return *this;
> }
>
>
>
>
>
>
> constexpr reverse_iterator
> operator-(difference_type __n) const
> { return reverse_iterator(current + __n); }
>
>
>
>
>
>
>
> constexpr reverse_iterator&
> operator-=(difference_type __n)
> {
> current += __n;
> return *this;
> }
>
>
>
>
>
>
> constexpr reference
> operator[](difference_type __n) const
> { return *(*this + __n); }
> };
># 297 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Iterator>
> inline constexpr bool
> operator==(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator<(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator!=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator>(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline constexpr bool
> operator<=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator>=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator==(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator<(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator!=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator>(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator<=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator>=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
># 387 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr auto
> operator-(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> -> decltype(__y.base() - __x.base())
> { return __y.base() - __x.base(); }
>
>
> template<typename _Iterator>
> inline constexpr reverse_iterator<_Iterator>
> operator+(typename reverse_iterator<_Iterator>::difference_type __n,
> const reverse_iterator<_Iterator>& __x)
> { return reverse_iterator<_Iterator>(__x.base() - __n); }
>
>
>
> template<typename _Iterator>
> inline constexpr reverse_iterator<_Iterator>
> __make_reverse_iterator(_Iterator __i)
> { return reverse_iterator<_Iterator>(__i); }
>
>
>
>
>
>
>
> template<typename _Iterator>
> inline constexpr reverse_iterator<_Iterator>
> make_reverse_iterator(_Iterator __i)
> { return reverse_iterator<_Iterator>(__i); }
>
>
>
>
> template<typename _Iterator>
> auto
> __niter_base(reverse_iterator<_Iterator> __it)
> -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
> { return __make_reverse_iterator(__niter_base(__it.base())); }
>
> template<typename _Iterator>
> struct __is_move_iterator<reverse_iterator<_Iterator> >
> : __is_move_iterator<_Iterator>
> { };
>
> template<typename _Iterator>
> auto
> __miter_base(reverse_iterator<_Iterator> __it)
> -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
> { return __make_reverse_iterator(__miter_base(__it.base())); }
># 451 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Container>
> class back_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit
> back_insert_iterator(_Container& __x)
> : container(std::__addressof(__x)) { }
># 486 "/usr/include/c++/8/bits/stl_iterator.h" 3
> back_insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> container->push_back(__value);
> return *this;
> }
>
> back_insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> container->push_back(std::move(__value));
> return *this;
> }
>
>
>
> back_insert_iterator&
> operator*()
> { return *this; }
>
>
> back_insert_iterator&
> operator++()
> { return *this; }
>
>
> back_insert_iterator
> operator++(int)
> { return *this; }
> };
># 528 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Container>
> inline back_insert_iterator<_Container>
> back_inserter(_Container& __x)
> { return back_insert_iterator<_Container>(__x); }
># 543 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Container>
> class front_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit front_insert_iterator(_Container& __x)
> : container(std::__addressof(__x)) { }
># 577 "/usr/include/c++/8/bits/stl_iterator.h" 3
> front_insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> container->push_front(__value);
> return *this;
> }
>
> front_insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> container->push_front(std::move(__value));
> return *this;
> }
>
>
>
> front_insert_iterator&
> operator*()
> { return *this; }
>
>
> front_insert_iterator&
> operator++()
> { return *this; }
>
>
> front_insert_iterator
> operator++(int)
> { return *this; }
> };
># 619 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Container>
> inline front_insert_iterator<_Container>
> front_inserter(_Container& __x)
> { return front_insert_iterator<_Container>(__x); }
># 638 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Container>
> class insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
> typename _Container::iterator iter;
>
> public:
>
> typedef _Container container_type;
>
>
>
>
>
> insert_iterator(_Container& __x, typename _Container::iterator __i)
> : container(std::__addressof(__x)), iter(__i) {}
># 689 "/usr/include/c++/8/bits/stl_iterator.h" 3
> insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> iter = container->insert(iter, __value);
> ++iter;
> return *this;
> }
>
> insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> iter = container->insert(iter, std::move(__value));
> ++iter;
> return *this;
> }
>
>
>
> insert_iterator&
> operator*()
> { return *this; }
>
>
> insert_iterator&
> operator++()
> { return *this; }
>
>
> insert_iterator&
> operator++(int)
> { return *this; }
> };
># 734 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Container, typename _Iterator>
> inline insert_iterator<_Container>
> inserter(_Container& __x, _Iterator __i)
> {
> return insert_iterator<_Container>(__x,
> typename _Container::iterator(__i));
> }
>
>
>
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 758 "/usr/include/c++/8/bits/stl_iterator.h" 3
> using std::iterator_traits;
> using std::iterator;
> template<typename _Iterator, typename _Container>
> class __normal_iterator
> {
> protected:
> _Iterator _M_current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::iterator_category iterator_category;
> typedef typename __traits_type::value_type value_type;
> typedef typename __traits_type::difference_type difference_type;
> typedef typename __traits_type::reference reference;
> typedef typename __traits_type::pointer pointer;
>
> constexpr __normal_iterator() noexcept
> : _M_current(_Iterator()) { }
>
> explicit
> __normal_iterator(const _Iterator& __i) noexcept
> : _M_current(__i) { }
>
>
> template<typename _Iter>
> __normal_iterator(const __normal_iterator<_Iter,
> typename __enable_if<
> (std::__are_same<_Iter, typename _Container::pointer>::__value),
> _Container>::__type>& __i) noexcept
> : _M_current(__i.base()) { }
>
>
> reference
> operator*() const noexcept
> { return *_M_current; }
>
> pointer
> operator->() const noexcept
> { return _M_current; }
>
> __normal_iterator&
> operator++() noexcept
> {
> ++_M_current;
> return *this;
> }
>
> __normal_iterator
> operator++(int) noexcept
> { return __normal_iterator(_M_current++); }
>
>
> __normal_iterator&
> operator--() noexcept
> {
> --_M_current;
> return *this;
> }
>
> __normal_iterator
> operator--(int) noexcept
> { return __normal_iterator(_M_current--); }
>
>
> reference
> operator[](difference_type __n) const noexcept
> { return _M_current[__n]; }
>
> __normal_iterator&
> operator+=(difference_type __n) noexcept
> { _M_current += __n; return *this; }
>
> __normal_iterator
> operator+(difference_type __n) const noexcept
> { return __normal_iterator(_M_current + __n); }
>
> __normal_iterator&
> operator-=(difference_type __n) noexcept
> { _M_current -= __n; return *this; }
>
> __normal_iterator
> operator-(difference_type __n) const noexcept
> { return __normal_iterator(_M_current - __n); }
>
> const _Iterator&
> base() const noexcept
> { return _M_current; }
> };
># 858 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> noexcept
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> noexcept
> { return __lhs.base() != __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() != __rhs.base(); }
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> noexcept
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> noexcept
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> noexcept
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> noexcept
> { return __lhs.base() >= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() >= __rhs.base(); }
>
>
>
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
>
>
> inline auto
> operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
> -> decltype(__lhs.base() - __rhs.base())
>
>
>
>
>
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline typename __normal_iterator<_Iterator, _Container>::difference_type
> operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> noexcept
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline __normal_iterator<_Iterator, _Container>
> operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
> __n, const __normal_iterator<_Iterator, _Container>& __i)
> noexcept
> { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Iterator, typename _Container>
> _Iterator
> __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
> { return __it.base(); }
># 1003 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class move_iterator
> {
> protected:
> _Iterator _M_current;
>
> typedef iterator_traits<_Iterator> __traits_type;
> typedef typename __traits_type::reference __base_ref;
>
> 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 _Iterator pointer;
>
>
> typedef typename conditional<is_reference<__base_ref>::value,
> typename remove_reference<__base_ref>::type&&,
> __base_ref>::type reference;
>
> constexpr
> move_iterator()
> : _M_current() { }
>
> explicit constexpr
> move_iterator(iterator_type __i)
> : _M_current(__i) { }
>
> template<typename _Iter>
> constexpr
> move_iterator(const move_iterator<_Iter>& __i)
> : _M_current(__i.base()) { }
>
> constexpr iterator_type
> base() const
> { return _M_current; }
>
> constexpr reference
> operator*() const
> { return static_cast<reference>(*_M_current); }
>
> constexpr pointer
> operator->() const
> { return _M_current; }
>
> constexpr move_iterator&
> operator++()
> {
> ++_M_current;
> return *this;
> }
>
> constexpr move_iterator
> operator++(int)
> {
> move_iterator __tmp = *this;
> ++_M_current;
> return __tmp;
> }
>
> constexpr move_iterator&
> operator--()
> {
> --_M_current;
> return *this;
> }
>
> constexpr move_iterator
> operator--(int)
> {
> move_iterator __tmp = *this;
> --_M_current;
> return __tmp;
> }
>
> constexpr move_iterator
> operator+(difference_type __n) const
> { return move_iterator(_M_current + __n); }
>
> constexpr move_iterator&
> operator+=(difference_type __n)
> {
> _M_current += __n;
> return *this;
> }
>
> constexpr move_iterator
> operator-(difference_type __n) const
> { return move_iterator(_M_current - __n); }
>
> constexpr move_iterator&
> operator-=(difference_type __n)
> {
> _M_current -= __n;
> return *this;
> }
>
> constexpr reference
> operator[](difference_type __n) const
> { return std::move(_M_current[__n]); }
> };
>
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator==(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator==(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator!=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator!=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator<(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __x.base() < __y.base(); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator<(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __x.base() < __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator<=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator<=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator>(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline constexpr bool
> operator>(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr bool
> operator>=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
>
> template<typename _Iterator>
> inline constexpr bool
> operator>=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline constexpr auto
> operator-(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> -> decltype(__x.base() - __y.base())
> { return __x.base() - __y.base(); }
>
> template<typename _Iterator>
> inline constexpr move_iterator<_Iterator>
> operator+(typename move_iterator<_Iterator>::difference_type __n,
> const move_iterator<_Iterator>& __x)
> { return __x + __n; }
>
> template<typename _Iterator>
> inline constexpr move_iterator<_Iterator>
> make_move_iterator(_Iterator __i)
> { return move_iterator<_Iterator>(__i); }
>
> template<typename _Iterator, typename _ReturnType
> = typename conditional<__move_if_noexcept_cond
> <typename iterator_traits<_Iterator>::value_type>::value,
> _Iterator, move_iterator<_Iterator>>::type>
> inline constexpr _ReturnType
> __make_move_if_noexcept_iterator(_Iterator __i)
> { return _ReturnType(__i); }
>
>
>
> template<typename _Tp, typename _ReturnType
> = typename conditional<__move_if_noexcept_cond<_Tp>::value,
> const _Tp*, move_iterator<_Tp*>>::type>
> inline constexpr _ReturnType
> __make_move_if_noexcept_iterator(_Tp* __i)
> { return _ReturnType(__i); }
>
>
>
> template<typename _Iterator>
> auto
> __niter_base(move_iterator<_Iterator> __it)
> -> decltype(make_move_iterator(__niter_base(__it.base())))
> { return make_move_iterator(__niter_base(__it.base())); }
>
> template<typename _Iterator>
> struct __is_move_iterator<move_iterator<_Iterator> >
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<typename _Iterator>
> auto
> __miter_base(move_iterator<_Iterator> __it)
> -> decltype(__miter_base(__it.base()))
> { return __miter_base(__it.base()); }
># 1250 "/usr/include/c++/8/bits/stl_iterator.h" 3
> template<typename _InputIterator>
> using __iter_key_t = remove_const_t<
> typename iterator_traits<_InputIterator>::value_type::first_type>;
>
> template<typename _InputIterator>
> using __iter_val_t =
> typename iterator_traits<_InputIterator>::value_type::second_type;
>
> template<typename _T1, typename _T2>
> struct pair;
>
> template<typename _InputIterator>
> using __iter_to_alloc_t =
> pair<add_const_t<__iter_key_t<_InputIterator>>,
> __iter_val_t<_InputIterator>>;
>
>
>
>
>}
># 68 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
>
># 1 "/usr/include/c++/8/debug/debug.h" 1 3
># 48 "/usr/include/c++/8/debug/debug.h" 3
>namespace std
>{
> namespace __debug { }
>}
>
>
>
>
>namespace __gnu_debug
>{
> using namespace std::__debug;
>}
># 70 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
>
># 1 "/usr/include/c++/8/bits/predefined_ops.h" 1 3
># 33 "/usr/include/c++/8/bits/predefined_ops.h" 3
>namespace __gnu_cxx
>{
>namespace __ops
>{
> struct _Iter_less_iter
> {
> template<typename _Iterator1, typename _Iterator2>
> constexpr
> bool
> operator()(_Iterator1 __it1, _Iterator2 __it2) const
> { return *__it1 < *__it2; }
> };
>
> constexpr
> inline _Iter_less_iter
> __iter_less_iter()
> { return _Iter_less_iter(); }
>
> struct _Iter_less_val
> {
>
> constexpr _Iter_less_val() = default;
>
>
>
>
> explicit
> _Iter_less_val(_Iter_less_iter) { }
>
> template<typename _Iterator, typename _Value>
> bool
> operator()(_Iterator __it, _Value& __val) const
> { return *__it < __val; }
> };
>
> inline _Iter_less_val
> __iter_less_val()
> { return _Iter_less_val(); }
>
> inline _Iter_less_val
> __iter_comp_val(_Iter_less_iter)
> { return _Iter_less_val(); }
>
> struct _Val_less_iter
> {
>
> constexpr _Val_less_iter() = default;
>
>
>
>
> explicit
> _Val_less_iter(_Iter_less_iter) { }
>
> template<typename _Value, typename _Iterator>
> bool
> operator()(_Value& __val, _Iterator __it) const
> { return __val < *__it; }
> };
>
> inline _Val_less_iter
> __val_less_iter()
> { return _Val_less_iter(); }
>
> inline _Val_less_iter
> __val_comp_iter(_Iter_less_iter)
> { return _Val_less_iter(); }
>
> struct _Iter_equal_to_iter
> {
> template<typename _Iterator1, typename _Iterator2>
> bool
> operator()(_Iterator1 __it1, _Iterator2 __it2) const
> { return *__it1 == *__it2; }
> };
>
> inline _Iter_equal_to_iter
> __iter_equal_to_iter()
> { return _Iter_equal_to_iter(); }
>
> struct _Iter_equal_to_val
> {
> template<typename _Iterator, typename _Value>
> bool
> operator()(_Iterator __it, _Value& __val) const
> { return *__it == __val; }
> };
>
> inline _Iter_equal_to_val
> __iter_equal_to_val()
> { return _Iter_equal_to_val(); }
>
> inline _Iter_equal_to_val
> __iter_comp_val(_Iter_equal_to_iter)
> { return _Iter_equal_to_val(); }
>
> template<typename _Compare>
> struct _Iter_comp_iter
> {
> _Compare _M_comp;
>
> explicit constexpr
> _Iter_comp_iter(_Compare __comp)
> : _M_comp(std::move(__comp))
> { }
>
> template<typename _Iterator1, typename _Iterator2>
> constexpr
> bool
> operator()(_Iterator1 __it1, _Iterator2 __it2)
> { return bool(_M_comp(*__it1, *__it2)); }
> };
>
> template<typename _Compare>
> constexpr
> inline _Iter_comp_iter<_Compare>
> __iter_comp_iter(_Compare __comp)
> { return _Iter_comp_iter<_Compare>(std::move(__comp)); }
>
> template<typename _Compare>
> struct _Iter_comp_val
> {
> _Compare _M_comp;
>
> explicit
> _Iter_comp_val(_Compare __comp)
> : _M_comp(std::move(__comp))
> { }
>
> explicit
> _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
> : _M_comp(__comp._M_comp)
> { }
>
>
> explicit
> _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
> : _M_comp(std::move(__comp._M_comp))
> { }
>
>
> template<typename _Iterator, typename _Value>
> bool
> operator()(_Iterator __it, _Value& __val)
> { return bool(_M_comp(*__it, __val)); }
> };
>
> template<typename _Compare>
> inline _Iter_comp_val<_Compare>
> __iter_comp_val(_Compare __comp)
> { return _Iter_comp_val<_Compare>(std::move(__comp)); }
>
> template<typename _Compare>
> inline _Iter_comp_val<_Compare>
> __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
> { return _Iter_comp_val<_Compare>(std::move(__comp)); }
>
> template<typename _Compare>
> struct _Val_comp_iter
> {
> _Compare _M_comp;
>
> explicit
> _Val_comp_iter(_Compare __comp)
> : _M_comp(std::move(__comp))
> { }
>
> explicit
> _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
> : _M_comp(__comp._M_comp)
> { }
>
>
> explicit
> _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
> : _M_comp(std::move(__comp._M_comp))
> { }
>
>
> template<typename _Value, typename _Iterator>
> bool
> operator()(_Value& __val, _Iterator __it)
> { return bool(_M_comp(__val, *__it)); }
> };
>
> template<typename _Compare>
> inline _Val_comp_iter<_Compare>
> __val_comp_iter(_Compare __comp)
> { return _Val_comp_iter<_Compare>(std::move(__comp)); }
>
> template<typename _Compare>
> inline _Val_comp_iter<_Compare>
> __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
> { return _Val_comp_iter<_Compare>(std::move(__comp)); }
>
> template<typename _Value>
> struct _Iter_equals_val
> {
> _Value& _M_value;
>
> explicit
> _Iter_equals_val(_Value& __value)
> : _M_value(__value)
> { }
>
> template<typename _Iterator>
> bool
> operator()(_Iterator __it)
> { return *__it == _M_value; }
> };
>
> template<typename _Value>
> inline _Iter_equals_val<_Value>
> __iter_equals_val(_Value& __val)
> { return _Iter_equals_val<_Value>(__val); }
>
> template<typename _Iterator1>
> struct _Iter_equals_iter
> {
> _Iterator1 _M_it1;
>
> explicit
> _Iter_equals_iter(_Iterator1 __it1)
> : _M_it1(__it1)
> { }
>
> template<typename _Iterator2>
> bool
> operator()(_Iterator2 __it2)
> { return *__it2 == *_M_it1; }
> };
>
> template<typename _Iterator>
> inline _Iter_equals_iter<_Iterator>
> __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
> { return _Iter_equals_iter<_Iterator>(__it); }
>
> template<typename _Predicate>
> struct _Iter_pred
> {
> _Predicate _M_pred;
>
> explicit
> _Iter_pred(_Predicate __pred)
> : _M_pred(std::move(__pred))
> { }
>
> template<typename _Iterator>
> bool
> operator()(_Iterator __it)
> { return bool(_M_pred(*__it)); }
> };
>
> template<typename _Predicate>
> inline _Iter_pred<_Predicate>
> __pred_iter(_Predicate __pred)
> { return _Iter_pred<_Predicate>(std::move(__pred)); }
>
> template<typename _Compare, typename _Value>
> struct _Iter_comp_to_val
> {
> _Compare _M_comp;
> _Value& _M_value;
>
> _Iter_comp_to_val(_Compare __comp, _Value& __value)
> : _M_comp(std::move(__comp)), _M_value(__value)
> { }
>
> template<typename _Iterator>
> bool
> operator()(_Iterator __it)
> { return bool(_M_comp(*__it, _M_value)); }
> };
>
> template<typename _Compare, typename _Value>
> _Iter_comp_to_val<_Compare, _Value>
> __iter_comp_val(_Compare __comp, _Value &__val)
> {
> return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
> }
>
> template<typename _Compare, typename _Iterator1>
> struct _Iter_comp_to_iter
> {
> _Compare _M_comp;
> _Iterator1 _M_it1;
>
> _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
> : _M_comp(std::move(__comp)), _M_it1(__it1)
> { }
>
> template<typename _Iterator2>
> bool
> operator()(_Iterator2 __it2)
> { return bool(_M_comp(*__it2, *_M_it1)); }
> };
>
> template<typename _Compare, typename _Iterator>
> inline _Iter_comp_to_iter<_Compare, _Iterator>
> __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
> {
> return _Iter_comp_to_iter<_Compare, _Iterator>(
> std::move(__comp._M_comp), __it);
> }
>
> template<typename _Predicate>
> struct _Iter_negate
> {
> _Predicate _M_pred;
>
> explicit
> _Iter_negate(_Predicate __pred)
> : _M_pred(std::move(__pred))
> { }
>
> template<typename _Iterator>
> bool
> operator()(_Iterator __it)
> { return !bool(_M_pred(*__it)); }
> };
>
> template<typename _Predicate>
> inline _Iter_negate<_Predicate>
> __negate(_Iter_pred<_Predicate> __pred)
> { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }
>
>}
>}
># 72 "/usr/include/c++/8/bits/stl_algobase.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 118 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
>
> 
>
> 
># 148 "/usr/include/c++/8/bits/stl_algobase.h" 3
> swap(*__a, *__b);
>
> }
># 164 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator2
> swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
> 
>
> 
>
> ;
>
> for (; __first1 != __last1; ++__first1, (void)++__first2)
> std::iter_swap(__first1, __first2);
> return __first2;
> }
># 192 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _Tp>
> constexpr
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__b < __a)
> return __b;
> return __a;
> }
># 216 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _Tp>
> constexpr
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__a < __b)
> return __b;
> return __a;
> }
># 240 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> constexpr
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__b, __a))
> return __b;
> return __a;
> }
># 262 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> constexpr
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__a, __b))
> return __b;
> return __a;
> }
>
>
>
> template<typename _Iterator>
> inline _Iterator
> __niter_base(_Iterator __it)
> { return __it; }
>
>
>
>
>
>
>
> template<bool, bool, typename>
> struct __copy_move
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, (void)++__first)
> *__result = *__first;
> return __result;
> }
> };
>
>
> template<typename _Category>
> struct __copy_move<true, false, _Category>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, (void)++__first)
> *__result = std::move(*__first);
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move<false, false, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = *__first;
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move<true, false, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = std::move(*__first);
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
>
> template<bool _IsMove>
> struct __copy_move<_IsMove, true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
>
> using __assignable = conditional<_IsMove,
> is_move_assignable<_Tp>,
> is_copy_assignable<_Tp>>;
>
> static_assert( __assignable::type::value, "type is not assignable" );
>
> const ptrdiff_t _Num = __last - __first;
> if (_Num)
> __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
> return __result + _Num;
> }
> };
>
> template<bool _IsMove, typename _II, typename _OI>
> inline _OI
> __copy_move_a(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::value_type _ValueTypeI;
> typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
> typedef typename iterator_traits<_II>::iterator_category _Category;
> const bool __simple = (__is_trivial(_ValueTypeI)
> && __is_pointer<_II>::__value
> && __is_pointer<_OI>::__value
> && __are_same<_ValueTypeI, _ValueTypeO>::__value);
>
> return std::__copy_move<_IsMove, __simple,
> _Category>::__copy_m(__first, __last, __result);
> }
>
>
>
> template<typename _CharT>
> struct char_traits;
>
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator;
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator;
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
> __copy_move_a2(_CharT*, _CharT*,
> ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
> __copy_move_a2(const _CharT*, const _CharT*,
> ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> _CharT*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
> istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
>
> template<bool _IsMove, typename _II, typename _OI>
> inline _OI
> __copy_move_a2(_II __first, _II __last, _OI __result)
> {
> return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
> std::__niter_base(__last),
> std::__niter_base(__result)));
> }
># 444 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _II, typename _OI>
> inline _OI
> copy(_II __first, _II __last, _OI __result)
> {
>
> 
> 
>
> ;
>
> return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
> (std::__miter_base(__first), std::__miter_base(__last),
> __result));
> }
># 477 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _II, typename _OI>
> inline _OI
> move(_II __first, _II __last, _OI __result)
> {
>
> 
> 
>
> ;
>
> return std::__copy_move_a2<true>(std::__miter_base(__first),
> std::__miter_base(__last), __result);
> }
>
>
>
>
>
>
> template<bool, bool, typename>
> struct __copy_move_backward
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = *--__last;
> return __result;
> }
> };
>
>
> template<typename _Category>
> struct __copy_move_backward<true, false, _Category>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = std::move(*--__last);
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move_backward<false, false, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = *--__last;
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move_backward<true, false, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = std::move(*--__last);
> return __result;
> }
> };
>
>
> template<bool _IsMove>
> struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
>
> using __assignable = conditional<_IsMove,
> is_move_assignable<_Tp>,
> is_copy_assignable<_Tp>>;
>
> static_assert( __assignable::type::value, "type is not assignable" );
>
> const ptrdiff_t _Num = __last - __first;
> if (_Num)
> __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
> return __result - _Num;
> }
> };
>
> template<bool _IsMove, typename _BI1, typename _BI2>
> inline _BI2
> __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typedef typename iterator_traits<_BI1>::value_type _ValueType1;
> typedef typename iterator_traits<_BI2>::value_type _ValueType2;
> typedef typename iterator_traits<_BI1>::iterator_category _Category;
> const bool __simple = (__is_trivial(_ValueType1)
> && __is_pointer<_BI1>::__value
> && __is_pointer<_BI2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__copy_move_backward<_IsMove, __simple,
> _Category>::__copy_move_b(__first,
> __last,
> __result);
> }
>
> template<bool _IsMove, typename _BI1, typename _BI2>
> inline _BI2
> __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> return _BI2(std::__copy_move_backward_a<_IsMove>
> (std::__niter_base(__first), std::__niter_base(__last),
> std::__niter_base(__result)));
> }
># 620 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _BI1, typename _BI2>
> inline _BI2
> copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
> (std::__miter_base(__first), std::__miter_base(__last),
> __result));
> }
># 656 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _BI1, typename _BI2>
> inline _BI2
> move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
> std::__miter_base(__last),
> __result);
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
> __fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> for (; __first != __last; ++__first)
> *__first = __value;
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
> __fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (; __first != __last; ++__first)
> *__first = __tmp;
> }
>
>
> template<typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
> __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
> {
> const _Tp __tmp = __c;
> if (const size_t __len = __last - __first)
> __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
> }
># 722 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
> {
>
> 
>
> ;
>
> std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
> __value);
> }
>
> template<typename _OutputIterator, typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
> __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, (void) ++__first)
> *__first = __value;
> return __first;
> }
>
> template<typename _OutputIterator, typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
> __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, (void) ++__first)
> *__first = __tmp;
> return __first;
> }
>
> template<typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
> __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
> {
> std::__fill_a(__first, __first + __n, __c);
> return __first + __n;
> }
># 782 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _OI, typename _Size, typename _Tp>
> inline _OI
> fill_n(_OI __first, _Size __n, const _Tp& __value)
> {
>
> 
>
> return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
> }
>
> template<bool _BoolType>
> struct __equal
> {
> template<typename _II1, typename _II2>
> static bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2)
> {
> for (; __first1 != __last1; ++__first1, (void) ++__first2)
> if (!(*__first1 == *__first2))
> return false;
> return true;
> }
> };
>
> template<>
> struct __equal<true>
> {
> template<typename _Tp>
> static bool
> equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
> {
> if (const size_t __len = (__last1 - __first1))
> return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
> return true;
> }
> };
>
> template<typename _II1, typename _II2>
> inline bool
> __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
> {
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> const bool __simple = ((__is_integer<_ValueType1>::__value
> || __is_pointer<_ValueType1>::__value)
> && __is_pointer<_II1>::__value
> && __is_pointer<_II2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__equal<__simple>::equal(__first1, __last1, __first2);
> }
>
> template<typename, typename>
> struct __lc_rai
> {
> template<typename _II1, typename _II2>
> static _II1
> __newlast1(_II1, _II1 __last1, _II2, _II2)
> { return __last1; }
>
> template<typename _II>
> static bool
> __cnd2(_II __first, _II __last)
> { return __first != __last; }
> };
>
> template<>
> struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
> {
> template<typename _RAI1, typename _RAI2>
> static _RAI1
> __newlast1(_RAI1 __first1, _RAI1 __last1,
> _RAI2 __first2, _RAI2 __last2)
> {
> const typename iterator_traits<_RAI1>::difference_type
> __diff1 = __last1 - __first1;
> const typename iterator_traits<_RAI2>::difference_type
> __diff2 = __last2 - __first2;
> return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
> }
>
> template<typename _RAI>
> static bool
> __cnd2(_RAI, _RAI)
> { return true; }
> };
>
> template<typename _II1, typename _II2, typename _Compare>
> bool
> __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2,
> _Compare __comp)
> {
> typedef typename iterator_traits<_II1>::iterator_category _Category1;
> typedef typename iterator_traits<_II2>::iterator_category _Category2;
> typedef std::__lc_rai<_Category1, _Category2> __rai_type;
>
> __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
> for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
> ++__first1, (void)++__first2)
> {
> if (__comp(__first1, __first2))
> return true;
> if (__comp(__first2, __first1))
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
>
> template<bool _BoolType>
> struct __lexicographical_compare
> {
> template<typename _II1, typename _II2>
> static bool __lc(_II1, _II1, _II2, _II2);
> };
>
> template<bool _BoolType>
> template<typename _II1, typename _II2>
> bool
> __lexicographical_compare<_BoolType>::
> __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
> {
> return std::__lexicographical_compare_impl(__first1, __last1,
> __first2, __last2,
> __gnu_cxx::__ops::__iter_less_iter());
> }
>
> template<>
> struct __lexicographical_compare<true>
> {
> template<typename _Tp, typename _Up>
> static bool
> __lc(const _Tp* __first1, const _Tp* __last1,
> const _Up* __first2, const _Up* __last2)
> {
> const size_t __len1 = __last1 - __first1;
> const size_t __len2 = __last2 - __first2;
> if (const size_t __len = std::min(__len1, __len2))
> if (int __result = __builtin_memcmp(__first1, __first2, __len))
> return __result < 0;
> return __len1 < __len2;
> }
> };
>
> template<typename _II1, typename _II2>
> inline bool
> __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2)
> {
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> const bool __simple =
> (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
> && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
> && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
> && __is_pointer<_II1>::__value
> && __is_pointer<_II2>::__value);
>
> return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
> __first2, __last2);
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__comp(__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 982 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
>
> return std::__lower_bound(__first, __last, __val,
> __gnu_cxx::__ops::__iter_less_val());
> }
>
>
>
> inline constexpr int
> __lg(int __n)
> { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
>
> inline constexpr unsigned
> __lg(unsigned __n)
> { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
>
> inline constexpr long
> __lg(long __n)
> { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
>
> inline constexpr unsigned long
> __lg(unsigned long __n)
> { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
>
> inline constexpr long long
> __lg(long long __n)
> { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
>
> inline constexpr unsigned long long
> __lg(unsigned long long __n)
> { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
>
>
># 1037 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__equal_aux(std::__niter_base(__first1),
> std::__niter_base(__last1),
> std::__niter_base(__first2));
> }
># 1069 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> inline bool
> equal(_IIter1 __first1, _IIter1 __last1,
> _IIter2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, (void)++__first2)
> if (!bool(__binary_pred(*__first1, *__first2)))
> return false;
> return true;
> }
>
>
>
> template<typename _II1, typename _II2>
> inline bool
> __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
> {
> using _RATag = random_access_iterator_tag;
> using _Cat1 = typename iterator_traits<_II1>::iterator_category;
> using _Cat2 = typename iterator_traits<_II2>::iterator_category;
> using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
> if (_RAIters())
> {
> auto __d1 = std::distance(__first1, __last1);
> auto __d2 = std::distance(__first2, __last2);
> if (__d1 != __d2)
> return false;
> return std::equal(__first1, __last1, __first2);
> }
>
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, (void)++__first2)
> if (!(*__first1 == *__first2))
> return false;
> return __first1 == __last1 && __first2 == __last2;
> }
>
>
> template<typename _II1, typename _II2, typename _BinaryPredicate>
> inline bool
> __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
> _BinaryPredicate __binary_pred)
> {
> using _RATag = random_access_iterator_tag;
> using _Cat1 = typename iterator_traits<_II1>::iterator_category;
> using _Cat2 = typename iterator_traits<_II2>::iterator_category;
> using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
> if (_RAIters())
> {
> auto __d1 = std::distance(__first1, __last1);
> auto __d2 = std::distance(__first2, __last2);
> if (__d1 != __d2)
> return false;
> return std::equal(__first1, __last1, __first2,
> __binary_pred);
> }
>
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, (void)++__first2)
> if (!bool(__binary_pred(*__first1, *__first2)))
> return false;
> return __first1 == __last1 && __first2 == __last2;
> }
># 1156 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__equal4(__first1, __last1, __first2, __last2);
> }
># 1188 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> inline bool
> equal(_IIter1 __first1, _IIter1 __last1,
> _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
> ;
>
> return std::__equal4(__first1, __last1, __first2, __last2,
> __binary_pred);
> }
># 1219 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> lexicographical_compare(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2)
> {
>
>
>
>
>
> 
> 
> 
> 
> ;
> ;
>
> return std::__lexicographical_compare_aux(std::__niter_base(__first1),
> std::__niter_base(__last1),
> std::__niter_base(__first2),
> std::__niter_base(__last2));
> }
># 1255 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2, typename _Compare>
> inline bool
> lexicographical_compare(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2, _Compare __comp)
> {
>
> 
> 
> ;
> ;
>
> return std::__lexicographical_compare_impl
> (__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> pair<_InputIterator1, _InputIterator2>
> __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _BinaryPredicate __binary_pred)
> {
> while (__first1 != __last1 && __binary_pred(__first1, __first2))
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 1298 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> inline pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__mismatch(__first1, __last1, __first2,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 1331 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> inline pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> return std::__mismatch(__first1, __last1, __first2,
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> }
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> pair<_InputIterator1, _InputIterator2>
> __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _BinaryPredicate __binary_pred)
> {
> while (__first1 != __last1 && __first2 != __last2
> && __binary_pred(__first1, __first2))
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 1378 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> inline pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__mismatch(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 1413 "/usr/include/c++/8/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> inline pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
> ;
>
> return std::__mismatch(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> }
>
>
>
>
>}
># 40 "/usr/include/c++/8/bits/char_traits.h" 2 3
>
># 1 "/usr/include/c++/8/cwchar" 1 3
># 39 "/usr/include/c++/8/cwchar" 3
> 
># 40 "/usr/include/c++/8/cwchar" 3
># 42 "/usr/include/c++/8/bits/char_traits.h" 2 3
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 61 "/usr/include/c++/8/bits/char_traits.h" 3
> template<typename _CharT>
> struct _Char_types
> {
> typedef unsigned long int_type;
> typedef std::streampos pos_type;
> typedef std::streamoff off_type;
> typedef std::mbstate_t state_type;
> };
># 86 "/usr/include/c++/8/bits/char_traits.h" 3
> template<typename _CharT>
> struct char_traits
> {
> typedef _CharT char_type;
> typedef typename _Char_types<_CharT>::int_type int_type;
> typedef typename _Char_types<_CharT>::pos_type pos_type;
> typedef typename _Char_types<_CharT>::off_type off_type;
> typedef typename _Char_types<_CharT>::state_type state_type;
>
> static constexpr void
> assign(char_type& __c1, const char_type& __c2)
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2)
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2)
> { return __c1 < __c2; }
>
> static constexpr int
> compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static constexpr std::size_t
> length(const char_type* __s);
>
> static constexpr const char_type*
> find(const char_type* __s, std::size_t __n, const char_type& __a);
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, std::size_t __n);
>
> static char_type*
> assign(char_type* __s, std::size_t __n, char_type __a);
>
> static constexpr char_type
> to_char_type(const int_type& __c)
> { return static_cast<char_type>(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c)
> { return static_cast<int_type>(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2)
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof()
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c)
> { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
> };
>
>
>
> template<typename _CharT>
> constexpr int
> char_traits<_CharT>::
> compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> for (std::size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> template<typename _CharT>
> constexpr std::size_t
> char_traits<_CharT>::
> length(const char_type* __p)
> {
> std::size_t __i = 0;
> while (!eq(__p[__i], char_type()))
> ++__i;
> return __i;
> }
>
> template<typename _CharT>
> constexpr const typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> find(const char_type* __s, std::size_t __n, const char_type& __a)
> {
> for (std::size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> move(char_type* __s1, const char_type* __s2, std::size_t __n)
> {
> return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
> __n * sizeof(char_type)));
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> copy(char_type* __s1, const char_type* __s2, std::size_t __n)
> {
>
> std::copy(__s2, __s2 + __n, __s1);
> return __s1;
> }
>
> template<typename _CharT>
> typename char_traits<_CharT>::char_type*
> char_traits<_CharT>::
> assign(char_type* __s, std::size_t __n, char_type __a)
> {
>
> std::fill_n(__s, __n, __a);
> return __s;
> }
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 227 "/usr/include/c++/8/bits/char_traits.h" 3
> template<typename _CharT>
> static inline __attribute__((__always_inline__)) constexpr bool
> __constant_string_p(const _CharT* __s)
> {
> while (__builtin_constant_p(*__s) && *__s)
> __s++;
> return __builtin_constant_p(*__s);
> }
># 244 "/usr/include/c++/8/bits/char_traits.h" 3
> template<typename _CharT>
> static inline __attribute__((__always_inline__)) constexpr bool
> __constant_char_array_p(const _CharT* __a, size_t __n)
> {
> size_t __i = 0;
> while (__builtin_constant_p(__a[__i]) && __i < __n)
> __i++;
> return __i == __n;
> }
># 268 "/usr/include/c++/8/bits/char_traits.h" 3
> template<class _CharT>
> struct char_traits : public __gnu_cxx::char_traits<_CharT>
> { };
>
>
>
> template<>
> struct char_traits<char>
> {
> typedef char char_type;
> typedef int int_type;
> typedef streampos pos_type;
> typedef streamoff off_type;
> typedef mbstate_t state_type;
>
> static constexpr void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> {
>
> return (static_cast<unsigned char>(__c1)
> < static_cast<unsigned char>(__c2));
> }
>
> static constexpr int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
>
> if (__builtin_constant_p(__n)
> && __constant_char_array_p(__s1, __n)
> && __constant_char_array_p(__s2, __n))
> return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
>
> if (__n == 0)
> return 0;
> return __builtin_memcmp(__s1, __s2, __n);
> }
>
> static constexpr size_t
> length(const char_type* __s)
> {
>
> if (__constant_string_p(__s))
> return __gnu_cxx::char_traits<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 (__builtin_constant_p(__n)
> && __builtin_constant_p(__a)
> && __constant_char_array_p(__s, __n))
> return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
>
> if (__n == 0)
> return 0;
> return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> if (__n == 0)
> return __s;
> return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return static_cast<char_type>(__c); }
>
>
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return (__c == eof()) ? 0 : __c; }
> };
>
>
>
>
> template<>
> struct char_traits<wchar_t>
> {
> typedef wchar_t char_type;
> typedef wint_t int_type;
> typedef streamoff off_type;
> typedef wstreampos pos_type;
> typedef mbstate_t state_type;
>
> static constexpr void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static constexpr int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
>
> if (__builtin_constant_p(__n)
> && __constant_char_array_p(__s1, __n)
> && __constant_char_array_p(__s2, __n))
> return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
>
> if (__n == 0)
> return 0;
> else
> return wmemcmp(__s1, __s2, __n);
> }
>
> static constexpr size_t
> length(const char_type* __s)
> {
>
> if (__constant_string_p(__s))
> return __gnu_cxx::char_traits<char_type>::length(__s);
> else
>
> return wcslen(__s);
> }
>
> static constexpr const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
>
> if (__builtin_constant_p(__n)
> && __builtin_constant_p(__a)
> && __constant_char_array_p(__s, __n))
> return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
>
> if (__n == 0)
> return 0;
> else
> return wmemchr(__s, __a, __n);
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return wmemmove(__s1, __s2, __n);
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return wmemcpy(__s1, __s2, __n);
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> if (__n == 0)
> return __s;
> return wmemset(__s, __a, __n);
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>((0xffffffffu)); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>
>}
>
>
>
>
># 1 "/usr/include/c++/8/cstdint" 1 3
># 32 "/usr/include/c++/8/cstdint" 3
> 
># 33 "/usr/include/c++/8/cstdint" 3
># 41 "/usr/include/c++/8/cstdint" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h" 1 3 4
># 9 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h" 3 4
># 1 "/usr/include/stdint.h" 1 3 4
># 26 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/libc-header-start.h" 1 3 4
># 27 "/usr/include/stdint.h" 2 3 4
># 1 "/usr/include/bits/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
>
>
>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 long int __quad_t;
>typedef unsigned long int __u_quad_t;
>
>
>
>
>
>
>
>typedef long int __intmax_t;
>typedef unsigned long int __uintmax_t;
># 130 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 131 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned long int __dev_t;
>typedef unsigned int __uid_t;
>typedef unsigned int __gid_t;
>typedef unsigned long int __ino_t;
>typedef unsigned long int __ino64_t;
>typedef unsigned int __mode_t;
>typedef unsigned long int __nlink_t;
>typedef long int __off_t;
>typedef long int __off64_t;
>typedef int __pid_t;
>typedef struct { int __val[2]; } __fsid_t;
>typedef long int __clock_t;
>typedef unsigned long int __rlim_t;
>typedef unsigned long int __rlim64_t;
>typedef unsigned int __id_t;
>typedef long int __time_t;
>typedef unsigned int __useconds_t;
>typedef long int __suseconds_t;
>
>typedef int __daddr_t;
>typedef int __key_t;
>
>
>typedef int __clockid_t;
>
>
>typedef void * __timer_t;
>
>
>typedef long int __blksize_t;
>
>
>
>
>typedef long int __blkcnt_t;
>typedef long int __blkcnt64_t;
>
>
>typedef unsigned long int __fsblkcnt_t;
>typedef unsigned long int __fsblkcnt64_t;
>
>
>typedef unsigned long int __fsfilcnt_t;
>typedef unsigned long int __fsfilcnt64_t;
>
>
>typedef long int __fsword_t;
>
>typedef long int __ssize_t;
>
>
>typedef long int __syscall_slong_t;
>
>typedef unsigned long int __syscall_ulong_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef char *__caddr_t;
>
>
>typedef long int __intptr_t;
>
>
>typedef unsigned int __socklen_t;
>
>
>
>
>typedef int __sig_atomic_t;
># 28 "/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-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;
># 35 "/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 signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>typedef long int int_least64_t;
>
>
>
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>typedef unsigned long int uint_least64_t;
># 68 "/usr/include/stdint.h" 3 4
>typedef signed char int_fast8_t;
>
>typedef long int int_fast16_t;
>typedef long int int_fast32_t;
>typedef long int int_fast64_t;
># 81 "/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;
># 97 "/usr/include/stdint.h" 3 4
>typedef long int intptr_t;
>
>
>typedef unsigned long int uintptr_t;
># 111 "/usr/include/stdint.h" 3 4
>typedef __intmax_t intmax_t;
>typedef __uintmax_t uintmax_t;
># 10 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h" 2 3 4
># 42 "/usr/include/c++/8/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;
>}
># 502 "/usr/include/c++/8/bits/char_traits.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<>
> struct char_traits<char16_t>
> {
> typedef char16_t char_type;
> typedef uint_least16_t int_type;
> typedef streamoff off_type;
> typedef u16streampos pos_type;
> typedef mbstate_t state_type;
>
> static constexpr void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static constexpr int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> static constexpr size_t
> length(const char_type* __s)
> {
> size_t __i = 0;
> while (!eq(__s[__i], char_type()))
> ++__i;
> return __i;
> }
>
> static constexpr const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return (static_cast<char_type*>
> (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return (static_cast<char_type*>
> (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> assign(__s[__i], __a);
> return __s;
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return __c == eof() ? int_type(0xfffd) : int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
> template<>
> struct char_traits<char32_t>
> {
> typedef char32_t char_type;
> typedef uint_least32_t int_type;
> typedef streamoff off_type;
> typedef u32streampos pos_type;
> typedef mbstate_t state_type;
>
> static constexpr void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static constexpr int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (lt(__s1[__i], __s2[__i]))
> return -1;
> else if (lt(__s2[__i], __s1[__i]))
> return 1;
> return 0;
> }
>
> static constexpr size_t
> length(const char_type* __s)
> {
> size_t __i = 0;
> while (!eq(__s[__i], char_type()))
> ++__i;
> return __i;
> }
>
> static constexpr const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return (static_cast<char_type*>
> (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> if (__n == 0)
> return __s1;
> return (static_cast<char_type*>
> (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> assign(__s[__i], __a);
> return __s;
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>}
># 41 "/usr/include/c++/8/ios" 2 3
># 1 "/usr/include/c++/8/bits/localefwd.h" 1 3
># 37 "/usr/include/c++/8/bits/localefwd.h" 3
> 
># 38 "/usr/include/c++/8/bits/localefwd.h" 3
>
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h" 1 3
># 39 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h" 3
> 
># 40 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h" 3
>
># 1 "/usr/include/c++/8/clocale" 1 3
># 39 "/usr/include/c++/8/clocale" 3
> 
># 40 "/usr/include/c++/8/clocale" 3
>
>
># 1 "/usr/include/locale.h" 1 3 4
># 28 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 29 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
>
>extern "C" {
># 51 "/usr/include/locale.h" 3 4
>struct lconv
>{
>
>
> char *decimal_point;
> char *thousands_sep;
>
>
>
>
>
> char *grouping;
>
>
>
>
>
> char *int_curr_symbol;
> char *currency_symbol;
> char *mon_decimal_point;
> char *mon_thousands_sep;
> char *mon_grouping;
> char *positive_sign;
> char *negative_sign;
> char int_frac_digits;
> char frac_digits;
>
> char p_cs_precedes;
>
> char p_sep_by_space;
>
> char n_cs_precedes;
>
> char n_sep_by_space;
>
>
>
>
>
>
> char p_sign_posn;
> char n_sign_posn;
>
>
> char int_p_cs_precedes;
>
> char int_p_sep_by_space;
>
> char int_n_cs_precedes;
>
> char int_n_sep_by_space;
>
>
>
>
>
>
> char int_p_sign_posn;
> char int_n_sign_posn;
># 118 "/usr/include/locale.h" 3 4
>};
>
>
>
>extern char *setlocale (int __category, const char *__locale) throw ();
>
>
>extern struct lconv *localeconv (void) throw ();
># 141 "/usr/include/locale.h" 3 4
>extern locale_t newlocale (int __category_mask, const char *__locale,
> locale_t __base) throw ();
># 176 "/usr/include/locale.h" 3 4
>extern locale_t duplocale (locale_t __dataset) throw ();
>
>
>
>extern void freelocale (locale_t __dataset) throw ();
>
>
>
>
>
>
>extern locale_t uselocale (locale_t __dataset) throw ();
>
>
>
>
>
>
>
>}
># 43 "/usr/include/c++/8/clocale" 2 3
># 51 "/usr/include/c++/8/clocale" 3
>namespace std
>{
> using ::lconv;
> using ::setlocale;
> using ::localeconv;
>}
># 42 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h" 2 3
>
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> extern "C" __typeof(uselocale) __uselocale;
>
>
>}
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> typedef __locale_t __c_locale;
>
>
>
>
>
> inline int
> __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
> char* __out,
> const int __size __attribute__ ((__unused__)),
> const char* __fmt, ...)
> {
>
> __c_locale __old = __gnu_cxx::__uselocale(__cloc);
># 88 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h" 3
> __builtin_va_list __args;
> __builtin_va_start(__args, __fmt);
>
>
> const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
>
>
>
>
> __builtin_va_end(__args);
>
>
> __gnu_cxx::__uselocale(__old);
>
>
>
>
>
>
>
> return __ret;
> }
>
>
>}
># 41 "/usr/include/c++/8/bits/localefwd.h" 2 3
>
># 1 "/usr/include/c++/8/cctype" 1 3
># 39 "/usr/include/c++/8/cctype" 3
> 
># 40 "/usr/include/c++/8/cctype" 3
>
>
># 1 "/usr/include/ctype.h" 1 3 4
># 28 "/usr/include/ctype.h" 3 4
>extern "C" {
># 39 "/usr/include/ctype.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 36 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 2 3 4
># 60 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 28 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/bits/byteswap-16.h" 1 3 4
># 36 "/usr/include/bits/byteswap.h" 2 3 4
># 44 "/usr/include/bits/byteswap.h" 3 4
>static __inline unsigned int
>__bswap_32 (unsigned int __bsx)
>{
> return __builtin_bswap32 (__bsx);
>}
># 108 "/usr/include/bits/byteswap.h" 3 4
>static __inline __uint64_t
>__bswap_64 (__uint64_t __bsx)
>{
> return __builtin_bswap64 (__bsx);
>}
># 61 "/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;
>}
># 62 "/usr/include/endian.h" 2 3 4
># 40 "/usr/include/ctype.h" 2 3 4
>
>
>
>
>
>
>enum
>{
> _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
> _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
> _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
> _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
> _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
> _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
> _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
> _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
> _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
> _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
> _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
> _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
>};
># 79 "/usr/include/ctype.h" 3 4
>extern const unsigned short int **__ctype_b_loc (void)
> throw () __attribute__ ((__const__));
>extern const __int32_t **__ctype_tolower_loc (void)
> throw () __attribute__ ((__const__));
>extern const __int32_t **__ctype_toupper_loc (void)
> throw () __attribute__ ((__const__));
># 108 "/usr/include/ctype.h" 3 4
>extern int isalnum (int) throw ();
>extern int isalpha (int) throw ();
>extern int iscntrl (int) throw ();
>extern int isdigit (int) throw ();
>extern int islower (int) throw ();
>extern int isgraph (int) throw ();
>extern int isprint (int) throw ();
>extern int ispunct (int) throw ();
>extern int isspace (int) throw ();
>extern int isupper (int) throw ();
>extern int isxdigit (int) throw ();
>
>
>
>extern int tolower (int __c) throw ();
>
>
>extern int toupper (int __c) throw ();
>
>
>
>
>extern int isblank (int) throw ();
>
>
>
>
>extern int isctype (int __c, int __mask) throw ();
>
>
>
>
>
>
>extern int isascii (int __c) throw ();
>
>
>
>extern int toascii (int __c) throw ();
>
>
>
>extern int _toupper (int) throw ();
>extern int _tolower (int) throw ();
># 251 "/usr/include/ctype.h" 3 4
>extern int isalnum_l (int, locale_t) throw ();
>extern int isalpha_l (int, locale_t) throw ();
>extern int iscntrl_l (int, locale_t) throw ();
>extern int isdigit_l (int, locale_t) throw ();
>extern int islower_l (int, locale_t) throw ();
>extern int isgraph_l (int, locale_t) throw ();
>extern int isprint_l (int, locale_t) throw ();
>extern int ispunct_l (int, locale_t) throw ();
>extern int isspace_l (int, locale_t) throw ();
>extern int isupper_l (int, locale_t) throw ();
>extern int isxdigit_l (int, locale_t) throw ();
>
>extern int isblank_l (int, locale_t) throw ();
>
>
>
>extern int __tolower_l (int __c, locale_t __l) throw ();
>extern int tolower_l (int __c, locale_t __l) throw ();
>
>
>extern int __toupper_l (int __c, locale_t __l) throw ();
>extern int toupper_l (int __c, locale_t __l) throw ();
># 327 "/usr/include/ctype.h" 3 4
>}
># 43 "/usr/include/c++/8/cctype" 2 3
># 62 "/usr/include/c++/8/cctype" 3
>namespace std
>{
> using ::isalnum;
> using ::isalpha;
> using ::iscntrl;
> using ::isdigit;
> using ::isgraph;
> using ::islower;
> using ::isprint;
> using ::ispunct;
> using ::isspace;
> using ::isupper;
> using ::isxdigit;
> using ::tolower;
> using ::toupper;
>}
>
>
>
>
>
>
>
>namespace std
>{
> using ::isblank;
>}
># 43 "/usr/include/c++/8/bits/localefwd.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/8/bits/localefwd.h" 3
> class locale;
>
> template<typename _Facet>
> bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> const _Facet&
> use_facet(const locale&);
>
>
> template<typename _CharT>
> bool
> isspace(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isprint(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> iscntrl(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isupper(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> islower(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isalpha(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isdigit(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> ispunct(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isxdigit(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isalnum(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isgraph(_CharT, const locale&);
>
>
> template<typename _CharT>
> bool
> isblank(_CharT, const locale&);
>
>
> template<typename _CharT>
> _CharT
> toupper(_CharT, const locale&);
>
> template<typename _CharT>
> _CharT
> tolower(_CharT, const locale&);
>
>
> class ctype_base;
> template<typename _CharT>
> class ctype;
> template<> class ctype<char>;
>
> template<> class ctype<wchar_t>;
>
> template<typename _CharT>
> class ctype_byname;
>
>
> class codecvt_base;
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt;
> template<> class codecvt<char, char, mbstate_t>;
>
> template<> class codecvt<wchar_t, char, mbstate_t>;
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname;
>
>
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class num_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class num_put;
>
>namespace __cxx11 {
> template<typename _CharT> class numpunct;
> template<typename _CharT> class numpunct_byname;
>}
>
>namespace __cxx11 {
>
> template<typename _CharT>
> class collate;
> template<typename _CharT>
> class collate_byname;
>}
>
>
> class time_base;
>namespace __cxx11 {
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get_byname;
>}
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put_byname;
>
>
> class money_base;
>namespace __cxx11 {
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class money_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class money_put;
>}
>namespace __cxx11 {
> template<typename _CharT, bool _Intl = false>
> class moneypunct;
> template<typename _CharT, bool _Intl = false>
> class moneypunct_byname;
>}
>
>
> class messages_base;
>namespace __cxx11 {
> template<typename _CharT>
> class messages;
> template<typename _CharT>
> class messages_byname;
>}
>
>
>}
># 42 "/usr/include/c++/8/ios" 2 3
># 1 "/usr/include/c++/8/bits/ios_base.h" 1 3
># 37 "/usr/include/c++/8/bits/ios_base.h" 3
> 
># 38 "/usr/include/c++/8/bits/ios_base.h" 3
>
># 1 "/usr/include/c++/8/ext/atomicity.h" 1 3
># 32 "/usr/include/c++/8/ext/atomicity.h" 3
> 
># 33 "/usr/include/c++/8/ext/atomicity.h" 3
>
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h" 1 3
># 30 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h" 3
>#pragma GCC visibility push(default)
># 148 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h" 3
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 1 3
># 35 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
># 1 "/usr/include/pthread.h" 1 3 4
># 23 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 29 "/usr/include/sched.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 30 "/usr/include/sched.h" 2 3 4
>
># 1 "/usr/include/bits/types/time_t.h" 1 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
>
>
>
>
>
>
>
>struct timespec
>{
> __time_t tv_sec;
> __syscall_slong_t tv_nsec;
>};
># 33 "/usr/include/sched.h" 2 3 4
>
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
># 1 "/usr/include/bits/sched.h" 1 3 4
># 75 "/usr/include/bits/sched.h" 3 4
>struct sched_param
>{
> int sched_priority;
>};
>
>extern "C" {
>
>
>
>extern int clone (int (*__fn) (void *__arg), void *__child_stack,
> int __flags, void *__arg, ...) throw ();
>
>
>extern int unshare (int __flags) throw ();
>
>
>extern int sched_getcpu (void) throw ();
>
>
>extern int setns (int __fd, int __nstype) throw ();
>
>
>}
># 44 "/usr/include/sched.h" 2 3 4
># 1 "/usr/include/bits/cpu-set.h" 1 3 4
># 32 "/usr/include/bits/cpu-set.h" 3 4
>typedef unsigned long int __cpu_mask;
>
>
>
>
>
>
>typedef struct
>{
> __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
>} cpu_set_t;
># 115 "/usr/include/bits/cpu-set.h" 3 4
>extern "C" {
>
>extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
> throw ();
>extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
>extern void __sched_cpufree (cpu_set_t *__set) throw ();
>
>}
># 45 "/usr/include/sched.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
>
>
>extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
> throw ();
>
>
>extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
>
>
>extern int sched_setscheduler (__pid_t __pid, int __policy,
> const struct sched_param *__param) throw ();
>
>
>extern int sched_getscheduler (__pid_t __pid) throw ();
>
>
>extern int sched_yield (void) throw ();
>
>
>extern int sched_get_priority_max (int __algorithm) throw ();
>
>
>extern int sched_get_priority_min (int __algorithm) throw ();
>
>
>extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
># 121 "/usr/include/sched.h" 3 4
>extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
> const cpu_set_t *__cpuset) throw ();
>
>
>extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
> cpu_set_t *__cpuset) throw ();
>
>
>}
># 24 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 29 "/usr/include/time.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 30 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 73 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 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
>{
> unsigned int modes;
> __syscall_slong_t offset;
> __syscall_slong_t freq;
> __syscall_slong_t maxerror;
> __syscall_slong_t esterror;
> int status;
> __syscall_slong_t constant;
> __syscall_slong_t precision;
> __syscall_slong_t tolerance;
> struct timeval time;
> __syscall_slong_t tick;
> __syscall_slong_t ppsfreq;
> __syscall_slong_t jitter;
> int shift;
> __syscall_slong_t stabil;
> __syscall_slong_t jitcnt;
> __syscall_slong_t calcnt;
> __syscall_slong_t errcnt;
> __syscall_slong_t stbcnt;
>
> int tai;
>
>
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32;
>};
># 74 "/usr/include/bits/time.h" 2 3 4
>
>extern "C" {
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
>
>}
># 34 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/types/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) throw ();
>
>
>extern time_t time (time_t *__timer) throw ();
>
>
>extern double difftime (time_t __time1, time_t __time0)
> throw () __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) throw ();
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
> const char *__restrict __format,
> const struct tm *__restrict __tp) throw ();
>
>
>
>
>extern char *strptime (const char *__restrict __s,
> const char *__restrict __fmt, struct tm *__tp)
> throw ();
>
>
>
>
>
>
>extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
> const char *__restrict __format,
> const struct tm *__restrict __tp,
> locale_t __loc) throw ();
>
>
>
>extern char *strptime_l (const char *__restrict __s,
> const char *__restrict __fmt, struct tm *__tp,
> locale_t __loc) throw ();
>
>
>
>
>
>extern struct tm *gmtime (const time_t *__timer) throw ();
>
>
>
>extern struct tm *localtime (const time_t *__timer) throw ();
>
>
>
>
>extern struct tm *gmtime_r (const time_t *__restrict __timer,
> struct tm *__restrict __tp) throw ();
>
>
>
>extern struct tm *localtime_r (const time_t *__restrict __timer,
> struct tm *__restrict __tp) throw ();
>
>
>
>
>extern char *asctime (const struct tm *__tp) throw ();
>
>
>extern char *ctime (const time_t *__timer) throw ();
>
>
>
>
>
>
>extern char *asctime_r (const struct tm *__restrict __tp,
> char *__restrict __buf) throw ();
>
>
>extern char *ctime_r (const time_t *__restrict __timer,
> char *__restrict __buf) throw ();
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) throw ();
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (const time_t *__when) throw ();
># 196 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) throw ();
>
>
>extern time_t timelocal (struct tm *__tp) throw ();
>
>
>extern int dysize (int __year) throw () __attribute__ ((__const__));
># 211 "/usr/include/time.h" 3 4
>extern int nanosleep (const struct timespec *__requested_time,
> struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
>
>
>extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
> throw ();
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
> const struct timespec *__req,
> struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
> struct sigevent *__restrict __evp,
> timer_t *__restrict __timerid) throw ();
>
>
>extern int timer_delete (timer_t __timerid) throw ();
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
> const struct itimerspec *__restrict __value,
> struct itimerspec *__restrict __ovalue) throw ();
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
> throw ();
>
>
>extern int timer_getoverrun (timer_t __timerid) throw ();
>
>
>
>
>
>extern int timespec_get (struct timespec *__ts, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
># 280 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 289 "/usr/include/time.h" 3 4
>extern struct tm *getdate (const char *__string);
># 303 "/usr/include/time.h" 3 4
>extern int getdate_r (const char *__restrict __string,
> struct tm *__restrict __resbufp);
>
>
>}
># 25 "/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
># 77 "/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
># 65 "/usr/include/bits/pthreadtypes-arch.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;
># 99 "/usr/include/bits/pthreadtypes-arch.h" 3 4
>};
># 78 "/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;
># 118 "/usr/include/bits/thread-shared-types.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;
># 145 "/usr/include/bits/thread-shared-types.h" 3 4
> 
>};
>
>
>
>
>struct __pthread_cond_s
>{
> __extension__ union
> {
> __extension__ unsigned long long int __wseq;
> struct
> {
> unsigned int __low;
> unsigned int __high;
> } __wseq32;
> };
> __extension__ union
> {
> __extension__ unsigned long long int __g1_start;
> struct
> {
> unsigned int __low;
> unsigned int __high;
> } __g1_start32;
> };
> unsigned int __g_refs[2] ;
> unsigned int __g_size[2];
> unsigned int __g1_orig_size;
> unsigned int __wrefs;
> unsigned int __g_signals[2];
>};
># 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
>
>
>
>typedef unsigned long int pthread_t;
>
>
>
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>union pthread_attr_t
>{
> char __size[56];
> long int __align;
>};
>
>typedef union pthread_attr_t pthread_attr_t;
>
>
>
>
>typedef union
>{
> struct __pthread_mutex_s __data;
> char __size[40];
> long int __align;
>} pthread_mutex_t;
>
>
>typedef union
>{
> struct __pthread_cond_s __data;
> char __size[48];
> __extension__ long long int __align;
>} pthread_cond_t;
>
>
>
>
>
>typedef union
>{
> struct __pthread_rwlock_arch_t __data;
> char __size[56];
> long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
> char __size[8];
> long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
> char __size[32];
> long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
> char __size[4];
> int __align;
>} pthread_barrierattr_t;
># 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
>
>
>
>
>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
>};
># 115 "/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
>};
># 156 "/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
>
>};
># 191 "/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
>
>};
># 229 "/usr/include/pthread.h" 3 4
>extern "C" {
>
>
>
>
>extern int pthread_create (pthread_t *__restrict __newthread,
> const pthread_attr_t *__restrict __attr,
> void *(*__start_routine) (void *),
> void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>
>extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
>
>
>
>
>
>
>
>extern int pthread_join (pthread_t __th, void **__thread_return);
>
>
>
>
>extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
>
>
>
>
>
>
>
>extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
> const struct timespec *__abstime);
>
>
>
>
>
>
>extern int pthread_detach (pthread_t __th) throw ();
>
>
>
>extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
>
>
>extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
> throw () __attribute__ ((__const__));
>
>
>
>
>
>
>
>extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_destroy (pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
> int *__detachstate)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
> int __detachstate)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
> size_t *__guardsize)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
> size_t __guardsize)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
> struct sched_param *__restrict __param)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
> const struct sched_param *__restrict
> __param) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
> __attr, int *__restrict __policy)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
> __attr, int *__restrict __inherit)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
> int __inherit)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
> int *__restrict __scope)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
> __attr, void **__restrict __stackaddr)
> throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
>
>
>
>
>
>extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
> void *__stackaddr)
> throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
>
>
>extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
> __attr, size_t *__restrict __stacksize)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
> size_t __stacksize)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
> void **__restrict __stackaddr,
> size_t *__restrict __stacksize)
> throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
>extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
> size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
> size_t __cpusetsize,
> const cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
> size_t __cpusetsize,
> cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>extern int pthread_getattr_default_np (pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
> const struct sched_param *__param)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getschedparam (pthread_t __target_thread,
> int *__restrict __policy,
> struct sched_param *__restrict __param)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
> throw ();
>
>
>
>
>extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
> size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int pthread_getconcurrency (void) throw ();
>
>
>extern int pthread_setconcurrency (int __level) throw ();
>
>
>
>
>
>
>
>extern int pthread_yield (void) throw ();
>
>
>
>
>extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
> const cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
> cpu_set_t *__cpuset)
> throw () __attribute__ ((__nonnull__ (3)));
># 495 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
> void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 507 "/usr/include/pthread.h" 3 4
>extern int pthread_setcancelstate (int __state, int *__oldstate);
>
>
>
>extern int pthread_setcanceltype (int __type, int *__oldtype);
>
>
>extern int pthread_cancel (pthread_t __th);
>
>
>
>
>extern void pthread_testcancel (void);
>
>
>
>
>typedef struct
>{
> struct
> {
> __jmp_buf __cancel_jmp_buf;
> int __mask_was_saved;
> } __cancel_jmp_buf[1];
> void *__pad[4];
>} __pthread_unwind_buf_t __attribute__ ((__aligned__));
># 541 "/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); }
>};
># 743 "/usr/include/pthread.h" 3 4
>struct __jmp_buf_tag;
>extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
>
>
>
>
>
>extern int pthread_mutex_init (pthread_mutex_t *__mutex,
> const pthread_mutexattr_t *__mutexattr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
> const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
> __restrict __mutex,
> int *__restrict __prioceiling)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
> int __prioceiling,
> int *__restrict __old_ceiling)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>
>extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
> throw () __attribute__ ((__nonnull__ (1)));
># 807 "/usr/include/pthread.h" 3 4
>extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
> __attr, int *__restrict __kind)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __protocol)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
> int __protocol)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
> __restrict __attr,
> int *__restrict __prioceiling)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
> int __prioceiling)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
> int *__robustness)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
> int *__robustness)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
> int __robustness)
> throw () __attribute__ ((__nonnull__ (1)));
>
>extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
> int __robustness)
> throw () __attribute__ ((__nonnull__ (1)));
># 889 "/usr/include/pthread.h" 3 4
>extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
> const pthread_rwlockattr_t *__restrict
> __attr) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
> const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
> const struct timespec *__restrict
> __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
> __restrict __attr,
> int *__restrict __pref)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
> int __pref) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
> const pthread_condattr_t *__restrict __cond_attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_destroy (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_signal (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_cond_broadcast (pthread_cond_t *__cond)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
> pthread_mutex_t *__restrict __mutex)
> __attribute__ ((__nonnull__ (1, 2)));
># 1001 "/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)));
>
>
>
>
>extern int pthread_condattr_init (pthread_condattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_condattr_getpshared (const pthread_condattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
> int __pshared) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_condattr_getclock (const pthread_condattr_t *
> __restrict __attr,
> __clockid_t *__restrict __clock_id)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
> __clockid_t __clock_id)
> throw () __attribute__ ((__nonnull__ (1)));
># 1045 "/usr/include/pthread.h" 3 4
>extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_lock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
> const pthread_barrierattr_t *__restrict
> __attr, unsigned int __count)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
> __restrict __attr,
> int *__restrict __pshared)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
> int __pshared)
> throw () __attribute__ ((__nonnull__ (1)));
># 1112 "/usr/include/pthread.h" 3 4
>extern int pthread_key_create (pthread_key_t *__key,
> void (*__destr_function) (void *))
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int pthread_key_delete (pthread_key_t __key) throw ();
>
>
>extern void *pthread_getspecific (pthread_key_t __key) throw ();
>
>
>extern int pthread_setspecific (pthread_key_t __key,
> const void *__pointer) throw () ;
>
>
>
>
>extern int pthread_getcpuclockid (pthread_t __thread_id,
> __clockid_t *__clock_id)
> throw () __attribute__ ((__nonnull__ (2)));
># 1146 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
> void (*__parent) (void),
> void (*__child) (void)) throw ();
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
>{
> return __thread1 == __thread2;
>}
>
>
>}
># 36 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 2 3
># 47 "/usr/include/c++/8/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;
># 101 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
>static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
>static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
>static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
>
>static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
>static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
>static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
>static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
>static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
>
>static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
>
>static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
>
>static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
>static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
>
>static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
>
>static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
>static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
>static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
>
>static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
>static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
>static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
>static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
>static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
>static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
>
>static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
>static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
>static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
>static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
>static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
># 236 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
>static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
># 246 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_active_p (void)
>{
> static void *const __gthread_active_ptr
> = __extension__ (void *) &__gthrw___pthread_key_create;
> return __gthread_active_ptr != 0;
>}
># 658 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
> void *__args)
>{
> return __gthrw_pthread_create (__threadid, __null, __func, __args);
>}
>
>static inline int
>__gthread_join (__gthread_t __threadid, void **__value_ptr)
>{
> return __gthrw_pthread_join (__threadid, __value_ptr);
>}
>
>static inline int
>__gthread_detach (__gthread_t __threadid)
>{
> return __gthrw_pthread_detach (__threadid);
>}
>
>static inline int
>__gthread_equal (__gthread_t __t1, __gthread_t __t2)
>{
> return __gthrw_pthread_equal (__t1, __t2);
>}
>
>static inline __gthread_t
>__gthread_self (void)
>{
> return __gthrw_pthread_self ();
>}
>
>static inline int
>__gthread_yield (void)
>{
> return __gthrw_sched_yield ();
>}
>
>static inline int
>__gthread_once (__gthread_once_t *__once, void (*__func) (void))
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_once (__once, __func);
> else
> return -1;
>}
>
>static inline int
>__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
>{
> return __gthrw_pthread_key_create (__key, __dtor);
>}
>
>static inline int
>__gthread_key_delete (__gthread_key_t __key)
>{
> return __gthrw_pthread_key_delete (__key);
>}
>
>static inline void *
>__gthread_getspecific (__gthread_key_t __key)
>{
> return __gthrw_pthread_getspecific (__key);
>}
>
>static inline int
>__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
>{
> return __gthrw_pthread_setspecific (__key, __ptr);
>}
>
>static inline void
>__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> __gthrw_pthread_mutex_init (__mutex, __null);
>}
>
>static inline int
>__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_destroy (__mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_lock (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_lock (__mutex);
> else
> return 0;
>}
>
>static inline int
>__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_trylock (__mutex);
> else
> return 0;
>}
>
>
>static inline int
>__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
> else
> return 0;
>}
>
>
>static inline int
>__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
>{
> if (__gthread_active_p ())
> return __gthrw_pthread_mutex_unlock (__mutex);
> else
> return 0;
>}
># 807 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_lock (__mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_trylock (__mutex);
>}
>
>
>static inline int
>__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> return __gthread_mutex_timedlock (__mutex, __abs_timeout);
>}
>
>
>static inline int
>__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_unlock (__mutex);
>}
>
>static inline int
>__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_mutex_destroy (__mutex);
>}
># 849 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_cond_broadcast (__gthread_cond_t *__cond)
>{
> return __gthrw_pthread_cond_broadcast (__cond);
>}
>
>static inline int
>__gthread_cond_signal (__gthread_cond_t *__cond)
>{
> return __gthrw_pthread_cond_signal (__cond);
>}
>
>static inline int
>__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
>{
> return __gthrw_pthread_cond_wait (__cond, __mutex);
>}
>
>static inline int
>__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
>}
>
>static inline int
>__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
> __gthread_recursive_mutex_t *__mutex)
>{
> return __gthread_cond_wait (__cond, __mutex);
>}
>
>static inline int
>__gthread_cond_destroy (__gthread_cond_t* __cond)
>{
> return __gthrw_pthread_cond_destroy (__cond);
>}
># 149 "/usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h" 2 3
>
>
>#pragma GCC visibility pop
># 36 "/usr/include/c++/8/ext/atomicity.h" 2 3
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h" 1 3
># 32 "/usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h" 3
>typedef int _Atomic_word;
># 37 "/usr/include/c++/8/ext/atomicity.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> static inline _Atomic_word
> __exchange_and_add(volatile _Atomic_word* __mem, int __val)
> { return __atomic_fetch_add(__mem, __val, 4); }
>
> static inline void
> __atomic_add(volatile _Atomic_word* __mem, int __val)
> { __atomic_fetch_add(__mem, __val, 4); }
># 64 "/usr/include/c++/8/ext/atomicity.h" 3
> static inline _Atomic_word
> __exchange_and_add_single(_Atomic_word* __mem, int __val)
> {
> _Atomic_word __result = *__mem;
> *__mem += __val;
> return __result;
> }
>
> static inline void
> __atomic_add_single(_Atomic_word* __mem, int __val)
> { *__mem += __val; }
>
> static inline _Atomic_word
> __attribute__ ((__unused__))
> __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
> {
>
> if (__gthread_active_p())
> return __exchange_and_add(__mem, __val);
> else
> return __exchange_and_add_single(__mem, __val);
>
>
>
> }
>
> static inline void
> __attribute__ ((__unused__))
> __atomic_add_dispatch(_Atomic_word* __mem, int __val)
> {
>
> if (__gthread_active_p())
> __atomic_add(__mem, __val);
> else
> __atomic_add_single(__mem, __val);
>
>
>
> }
>
>
>}
># 40 "/usr/include/c++/8/bits/ios_base.h" 2 3
>
># 1 "/usr/include/c++/8/bits/locale_classes.h" 1 3
># 37 "/usr/include/c++/8/bits/locale_classes.h" 3
> 
># 38 "/usr/include/c++/8/bits/locale_classes.h" 3
>
>
># 1 "/usr/include/c++/8/string" 1 3
># 36 "/usr/include/c++/8/string" 3
> 
># 37 "/usr/include/c++/8/string" 3
>
>
>
>
># 1 "/usr/include/c++/8/bits/allocator.h" 1 3
># 46 "/usr/include/c++/8/bits/allocator.h" 3
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h" 1 3
># 33 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h" 3
># 1 "/usr/include/c++/8/ext/new_allocator.h" 1 3
># 40 "/usr/include/c++/8/ext/new_allocator.h" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> using std::size_t;
> using std::ptrdiff_t;
># 57 "/usr/include/c++/8/ext/new_allocator.h" 3
> template<typename _Tp>
> class new_allocator
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef new_allocator<_Tp1> other; };
>
>
>
>
> typedef std::true_type propagate_on_container_move_assignment;
>
>
> new_allocator() noexcept { }
>
> new_allocator(const new_allocator&) noexcept { }
>
> template<typename _Tp1>
> new_allocator(const new_allocator<_Tp1>&) noexcept { }
>
> ~new_allocator() noexcept { }
>
> pointer
> address(reference __x) const noexcept
> { return std::__addressof(__x); }
>
> const_pointer
> address(const_reference __x) const noexcept
> { return std::__addressof(__x); }
>
>
>
> pointer
> allocate(size_type __n, const void* = static_cast<const void*>(0))
> {
> if (__n > this->max_size())
> std::__throw_bad_alloc();
>
>
> if (alignof(_Tp) > 16)
> {
> std::align_val_t __al = std::align_val_t(alignof(_Tp));
> return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
> }
>
> return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
> }
>
>
> void
> deallocate(pointer __p, size_type)
> {
>
> if (alignof(_Tp) > 16)
> {
> ::operator delete(__p, std::align_val_t(alignof(_Tp)));
> return;
> }
>
> ::operator delete(__p);
> }
>
> size_type
> max_size() const noexcept
> { return size_t(-1) / sizeof(_Tp); }
>
>
> template<typename _Up, typename... _Args>
> void
> construct(_Up* __p, _Args&&... __args)
> { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
>
> template<typename _Up>
> void
> destroy(_Up* __p) { __p->~_Up(); }
># 151 "/usr/include/c++/8/ext/new_allocator.h" 3
> };
>
> template<typename _Tp>
> inline bool
> operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return false; }
>
>
>}
># 34 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h" 2 3
>
>
>namespace std
>{
># 47 "/usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h" 3
> template<typename _Tp>
> using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
>}
># 47 "/usr/include/c++/8/bits/allocator.h" 2 3
># 57 "/usr/include/c++/8/bits/allocator.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<>
> class allocator<void>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef void* pointer;
> typedef const void* const_pointer;
> typedef void value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
>
>
>
>
> typedef true_type propagate_on_container_move_assignment;
>
> typedef true_type is_always_equal;
>
> template<typename _Up, typename... _Args>
> void
> construct(_Up* __p, _Args&&... __args)
> { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
>
> template<typename _Up>
> void
> destroy(_Up* __p) { __p->~_Up(); }
>
> };
># 107 "/usr/include/c++/8/bits/allocator.h" 3
> template<typename _Tp>
> class allocator : public __allocator_base<_Tp>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
>
>
>
>
> typedef true_type propagate_on_container_move_assignment;
>
> typedef true_type is_always_equal;
>
>
> allocator() throw() { }
>
> allocator(const allocator& __a) throw()
> : __allocator_base<_Tp>(__a) { }
>
> template<typename _Tp1>
> allocator(const allocator<_Tp1>&) throw() { }
>
> ~allocator() throw() { }
>
>
> };
>
> template<typename _T1, typename _T2>
> inline bool
> operator==(const allocator<_T1>&, const allocator<_T2>&)
> noexcept
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator==(const allocator<_Tp>&, const allocator<_Tp>&)
> noexcept
> { return true; }
>
> template<typename _T1, typename _T2>
> inline bool
> operator!=(const allocator<_T1>&, const allocator<_T2>&)
> noexcept
> { return false; }
>
> template<typename _Tp>
> inline bool
> operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
> noexcept
> { return false; }
>
>
>
> template<typename _Tp>
> class allocator<const _Tp>
> {
> public:
> typedef _Tp value_type;
> template<typename _Up> allocator(const allocator<_Up>&) { }
> };
>
> template<typename _Tp>
> class allocator<volatile _Tp>
> {
> public:
> typedef _Tp value_type;
> template<typename _Up> allocator(const allocator<_Up>&) { }
> };
>
> template<typename _Tp>
> class allocator<const volatile _Tp>
> {
> public:
> typedef _Tp value_type;
> template<typename _Up> allocator(const allocator<_Up>&) { }
> };
>
>
>
>
>
>
> extern template class allocator<char>;
> extern template class allocator<wchar_t>;
>
>
>
>
>
>
> template<typename _Alloc, bool = __is_empty(_Alloc)>
> struct __alloc_swap
> { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
>
> template<typename _Alloc>
> struct __alloc_swap<_Alloc, false>
> {
> static void
> _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
> {
>
> if (__one != __two)
> swap(__one, __two);
> }
> };
>
>
> template<typename _Alloc, bool = __is_empty(_Alloc)>
> struct __alloc_neq
> {
> static bool
> _S_do_it(const _Alloc&, const _Alloc&)
> { return false; }
> };
>
> template<typename _Alloc>
> struct __alloc_neq<_Alloc, false>
> {
> static bool
> _S_do_it(const _Alloc& __one, const _Alloc& __two)
> { return __one != __two; }
> };
>
>
> template<typename _Tp, bool
> = __or_<is_copy_constructible<typename _Tp::value_type>,
> is_nothrow_move_constructible<typename _Tp::value_type>>::value>
> struct __shrink_to_fit_aux
> { static bool _S_do_it(_Tp&) noexcept { return false; } };
>
> template<typename _Tp>
> struct __shrink_to_fit_aux<_Tp, true>
> {
> static bool
> _S_do_it(_Tp& __c) noexcept
> {
>
> try
> {
> _Tp(__make_move_if_noexcept_iterator(__c.begin()),
> __make_move_if_noexcept_iterator(__c.end()),
> __c.get_allocator()).swap(__c);
> return true;
> }
> catch(...)
> { return false; }
>
>
>
> }
> };
>
>
>
>}
># 42 "/usr/include/c++/8/string" 2 3
>
>
># 1 "/usr/include/c++/8/bits/ostream_insert.h" 1 3
># 33 "/usr/include/c++/8/bits/ostream_insert.h" 3
> 
># 34 "/usr/include/c++/8/bits/ostream_insert.h" 3
>
>
># 1 "/usr/include/c++/8/bits/cxxabi_forced.h" 1 3
># 34 "/usr/include/c++/8/bits/cxxabi_forced.h" 3
> 
># 35 "/usr/include/c++/8/bits/cxxabi_forced.h" 3
>
>#pragma GCC visibility push(default)
>
>
>namespace __cxxabiv1
>{
>
>
>
>
>
>
>
> class __forced_unwind
> {
> virtual ~__forced_unwind() throw();
>
>
> virtual void __pure_dummy() = 0;
> };
>}
>
>
>#pragma GCC visibility pop
># 37 "/usr/include/c++/8/bits/ostream_insert.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> inline void
> __ostream_write(basic_ostream<_CharT, _Traits>& __out,
> const _CharT* __s, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const streamsize __put = __out.rdbuf()->sputn(__s, __n);
> if (__put != __n)
> __out.setstate(__ios_base::badbit);
> }
>
> template<typename _CharT, typename _Traits>
> inline void
> __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const _CharT __c = __out.fill();
> for (; __n > 0; --__n)
> {
> const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
> if (_Traits::eq_int_type(__put, _Traits::eof()))
> {
> __out.setstate(__ios_base::badbit);
> break;
> }
> }
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
> const _CharT* __s, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> if (__w > __n)
> {
> const bool __left = ((__out.flags()
> & __ios_base::adjustfield)
> == __ios_base::left);
> if (!__left)
> __ostream_fill(__out, __w - __n);
> if (__out.good())
> __ostream_write(__out, __s, __n);
> if (__left && __out.good())
> __ostream_fill(__out, __w - __n);
> }
> else
> __ostream_write(__out, __s, __n);
> __out.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __out._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> { __out._M_setstate(__ios_base::badbit); }
> }
> return __out;
> }
>
>
>
>
> extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
>
>
> extern template wostream& __ostream_insert(wostream&, const wchar_t*,
> streamsize);
>
>
>
>
>}
># 45 "/usr/include/c++/8/string" 2 3
>
>
>
># 1 "/usr/include/c++/8/bits/stl_function.h" 1 3
># 63 "/usr/include/c++/8/bits/stl_function.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 104 "/usr/include/c++/8/bits/stl_function.h" 3
> template<typename _Arg, typename _Result>
> struct unary_function
> {
>
> typedef _Arg argument_type;
>
>
> typedef _Result result_type;
> };
>
>
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> struct binary_function
> {
>
> typedef _Arg1 first_argument_type;
>
>
> typedef _Arg2 second_argument_type;
>
>
> typedef _Result result_type;
> };
># 144 "/usr/include/c++/8/bits/stl_function.h" 3
> struct __is_transparent;
>
> template<typename _Tp = void>
> struct plus;
>
> template<typename _Tp = void>
> struct minus;
>
> template<typename _Tp = void>
> struct multiplies;
>
> template<typename _Tp = void>
> struct divides;
>
> template<typename _Tp = void>
> struct modulus;
>
> template<typename _Tp = void>
> struct negate;
>
>
>
> template<typename _Tp>
> struct plus : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x + __y; }
> };
>
>
> template<typename _Tp>
> struct minus : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x - __y; }
> };
>
>
> template<typename _Tp>
> struct multiplies : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x * __y; }
> };
>
>
> template<typename _Tp>
> struct divides : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x / __y; }
> };
>
>
> template<typename _Tp>
> struct modulus : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x % __y; }
> };
>
>
> template<typename _Tp>
> struct negate : public unary_function<_Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x) const
> { return -__x; }
> };
>
>
>
>
>
> template<>
> struct plus<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct minus<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct multiplies<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct divides<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct modulus<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct negate<void>
> {
> template <typename _Tp>
> constexpr
> auto
> operator()(_Tp&& __t) const
> noexcept(noexcept(-std::forward<_Tp>(__t)))
> -> decltype(-std::forward<_Tp>(__t))
> { return -std::forward<_Tp>(__t); }
>
> typedef __is_transparent is_transparent;
> };
># 330 "/usr/include/c++/8/bits/stl_function.h" 3
> template<typename _Tp = void>
> struct equal_to;
>
> template<typename _Tp = void>
> struct not_equal_to;
>
> template<typename _Tp = void>
> struct greater;
>
> template<typename _Tp = void>
> struct less;
>
> template<typename _Tp = void>
> struct greater_equal;
>
> template<typename _Tp = void>
> struct less_equal;
>
>
>
> template<typename _Tp>
> struct equal_to : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x == __y; }
> };
>
>
> template<typename _Tp>
> struct not_equal_to : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x != __y; }
> };
>
>
> template<typename _Tp>
> struct greater : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x > __y; }
> };
>
>
> template<typename _Tp>
> struct less : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x < __y; }
> };
>
>
> template<typename _Tp>
> struct greater_equal : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x >= __y; }
> };
>
>
> template<typename _Tp>
> struct less_equal : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x <= __y; }
> };
>
>
> template<typename _Tp>
> struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
> {
> constexpr bool
> operator()(_Tp* __x, _Tp* __y) const noexcept
> {
> if (__builtin_constant_p (__x > __y))
> return __x > __y;
> return (long unsigned int)__x > (long unsigned int)__y;
> }
> };
>
>
> template<typename _Tp>
> struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
> {
> constexpr bool
> operator()(_Tp* __x, _Tp* __y) const noexcept
> {
> if (__builtin_constant_p (__x < __y))
> return __x < __y;
> return (long unsigned int)__x < (long unsigned int)__y;
> }
> };
>
>
> template<typename _Tp>
> struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
> {
> constexpr bool
> operator()(_Tp* __x, _Tp* __y) const noexcept
> {
> if (__builtin_constant_p (__x >= __y))
> return __x >= __y;
> return (long unsigned int)__x >= (long unsigned int)__y;
> }
> };
>
>
> template<typename _Tp>
> struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
> {
> constexpr bool
> operator()(_Tp* __x, _Tp* __y) const noexcept
> {
> if (__builtin_constant_p (__x <= __y))
> return __x <= __y;
> return (long unsigned int)__x <= (long unsigned int)__y;
> }
> };
>
>
>
> template<>
> struct equal_to<void>
> {
> template <typename _Tp, typename _Up>
> constexpr auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct not_equal_to<void>
> {
> template <typename _Tp, typename _Up>
> constexpr auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct greater<void>
> {
> template <typename _Tp, typename _Up>
> constexpr auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
> {
> return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
> __ptr_cmp<_Tp, _Up>{});
> }
>
> template<typename _Tp, typename _Up>
> constexpr bool
> operator()(_Tp* __t, _Up* __u) const noexcept
> { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
>
> typedef __is_transparent is_transparent;
>
> private:
> template <typename _Tp, typename _Up>
> static constexpr decltype(auto)
> _S_cmp(_Tp&& __t, _Up&& __u, false_type)
> { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
>
> template <typename _Tp, typename _Up>
> static constexpr bool
> _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
> {
> return greater<const volatile void*>{}(
> static_cast<const volatile void*>(std::forward<_Tp>(__t)),
> static_cast<const volatile void*>(std::forward<_Up>(__u)));
> }
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded2 : true_type { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded2<_Tp, _Up, __void_t<
> decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
> : false_type { };
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded<_Tp, _Up, __void_t<
> decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
> : false_type { };
>
> template<typename _Tp, typename _Up>
> using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
> is_convertible<_Tp, const volatile void*>,
> is_convertible<_Up, const volatile void*>>;
> };
>
>
> template<>
> struct less<void>
> {
> template <typename _Tp, typename _Up>
> constexpr auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
> {
> return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
> __ptr_cmp<_Tp, _Up>{});
> }
>
> template<typename _Tp, typename _Up>
> constexpr bool
> operator()(_Tp* __t, _Up* __u) const noexcept
> { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
>
> typedef __is_transparent is_transparent;
>
> private:
> template <typename _Tp, typename _Up>
> static constexpr decltype(auto)
> _S_cmp(_Tp&& __t, _Up&& __u, false_type)
> { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
>
> template <typename _Tp, typename _Up>
> static constexpr bool
> _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
> {
> return less<const volatile void*>{}(
> static_cast<const volatile void*>(std::forward<_Tp>(__t)),
> static_cast<const volatile void*>(std::forward<_Up>(__u)));
> }
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded2 : true_type { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded2<_Tp, _Up, __void_t<
> decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
> : false_type { };
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded<_Tp, _Up, __void_t<
> decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
> : false_type { };
>
> template<typename _Tp, typename _Up>
> using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
> is_convertible<_Tp, const volatile void*>,
> is_convertible<_Up, const volatile void*>>;
> };
>
>
> template<>
> struct greater_equal<void>
> {
> template <typename _Tp, typename _Up>
> constexpr auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
> {
> return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
> __ptr_cmp<_Tp, _Up>{});
> }
>
> template<typename _Tp, typename _Up>
> constexpr bool
> operator()(_Tp* __t, _Up* __u) const noexcept
> { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
>
> typedef __is_transparent is_transparent;
>
> private:
> template <typename _Tp, typename _Up>
> static constexpr decltype(auto)
> _S_cmp(_Tp&& __t, _Up&& __u, false_type)
> { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
>
> template <typename _Tp, typename _Up>
> static constexpr bool
> _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
> {
> return greater_equal<const volatile void*>{}(
> static_cast<const volatile void*>(std::forward<_Tp>(__t)),
> static_cast<const volatile void*>(std::forward<_Up>(__u)));
> }
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded2 : true_type { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded2<_Tp, _Up, __void_t<
> decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
> : false_type { };
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded<_Tp, _Up, __void_t<
> decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
> : false_type { };
>
> template<typename _Tp, typename _Up>
> using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
> is_convertible<_Tp, const volatile void*>,
> is_convertible<_Up, const volatile void*>>;
> };
>
>
> template<>
> struct less_equal<void>
> {
> template <typename _Tp, typename _Up>
> constexpr auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
> {
> return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
> __ptr_cmp<_Tp, _Up>{});
> }
>
> template<typename _Tp, typename _Up>
> constexpr bool
> operator()(_Tp* __t, _Up* __u) const noexcept
> { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
>
> typedef __is_transparent is_transparent;
>
> private:
> template <typename _Tp, typename _Up>
> static constexpr decltype(auto)
> _S_cmp(_Tp&& __t, _Up&& __u, false_type)
> { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
>
> template <typename _Tp, typename _Up>
> static constexpr bool
> _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
> {
> return less_equal<const volatile void*>{}(
> static_cast<const volatile void*>(std::forward<_Tp>(__t)),
> static_cast<const volatile void*>(std::forward<_Up>(__u)));
> }
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded2 : true_type { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded2<_Tp, _Up, __void_t<
> decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
> : false_type { };
>
>
> template<typename _Tp, typename _Up, typename = void>
> struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
>
>
> template<typename _Tp, typename _Up>
> struct __not_overloaded<_Tp, _Up, __void_t<
> decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
> : false_type { };
>
> template<typename _Tp, typename _Up>
> using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
> is_convertible<_Tp, const volatile void*>,
> is_convertible<_Up, const volatile void*>>;
> };
># 750 "/usr/include/c++/8/bits/stl_function.h" 3
> template<typename _Tp = void>
> struct logical_and;
>
> template<typename _Tp = void>
> struct logical_or;
>
> template<typename _Tp = void>
> struct logical_not;
>
>
>
> template<typename _Tp>
> struct logical_and : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x && __y; }
> };
>
>
> template<typename _Tp>
> struct logical_or : public binary_function<_Tp, _Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x || __y; }
> };
>
>
> template<typename _Tp>
> struct logical_not : public unary_function<_Tp, bool>
> {
> constexpr
> bool
> operator()(const _Tp& __x) const
> { return !__x; }
> };
>
>
>
> template<>
> struct logical_and<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct logical_or<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
>
> template<>
> struct logical_not<void>
> {
> template <typename _Tp>
> constexpr
> auto
> operator()(_Tp&& __t) const
> noexcept(noexcept(!std::forward<_Tp>(__t)))
> -> decltype(!std::forward<_Tp>(__t))
> { return !std::forward<_Tp>(__t); }
>
> typedef __is_transparent is_transparent;
> };
>
>
>
>
> template<typename _Tp = void>
> struct bit_and;
>
> template<typename _Tp = void>
> struct bit_or;
>
> template<typename _Tp = void>
> struct bit_xor;
>
> template<typename _Tp = void>
> struct bit_not;
>
>
>
>
> template<typename _Tp>
> struct bit_and : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x & __y; }
> };
>
> template<typename _Tp>
> struct bit_or : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x | __y; }
> };
>
> template<typename _Tp>
> struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x ^ __y; }
> };
>
> template<typename _Tp>
> struct bit_not : public unary_function<_Tp, _Tp>
> {
> constexpr
> _Tp
> operator()(const _Tp& __x) const
> { return ~__x; }
> };
>
>
> template <>
> struct bit_and<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
> template <>
> struct bit_or<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
> template <>
> struct bit_xor<void>
> {
> template <typename _Tp, typename _Up>
> constexpr
> auto
> operator()(_Tp&& __t, _Up&& __u) const
> noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
> -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
> { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
>
> typedef __is_transparent is_transparent;
> };
>
> template <>
> struct bit_not<void>
> {
> template <typename _Tp>
> constexpr
> auto
> operator()(_Tp&& __t) const
> noexcept(noexcept(~std::forward<_Tp>(__t)))
> -> decltype(~std::forward<_Tp>(__t))
> { return ~std::forward<_Tp>(__t); }
>
> typedef __is_transparent is_transparent;
> };
># 978 "/usr/include/c++/8/bits/stl_function.h" 3
> template<typename _Predicate>
> class unary_negate
> : public unary_function<typename _Predicate::argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
>
> public:
> constexpr
> explicit
> unary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
> constexpr
> bool
> operator()(const typename _Predicate::argument_type& __x) const
> { return !_M_pred(__x); }
> };
>
>
> template<typename _Predicate>
> constexpr
> inline unary_negate<_Predicate>
> not1(const _Predicate& __pred)
> { return unary_negate<_Predicate>(__pred); }
>
>
> template<typename _Predicate>
> class binary_negate
> : public binary_function<typename _Predicate::first_argument_type,
> typename _Predicate::second_argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
>
> public:
> constexpr
> explicit
> binary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
> constexpr
> bool
> operator()(const typename _Predicate::first_argument_type& __x,
> const typename _Predicate::second_argument_type& __y) const
> { return !_M_pred(__x, __y); }
> };
>
>
> template<typename _Predicate>
> constexpr
> inline binary_negate<_Predicate>
> not2(const _Predicate& __pred)
> { return binary_negate<_Predicate>(__pred); }
># 1055 "/usr/include/c++/8/bits/stl_function.h" 3
> template<typename _Arg, typename _Result>
> class pointer_to_unary_function : public unary_function<_Arg, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg);
>
> public:
> pointer_to_unary_function() { }
>
> explicit
> pointer_to_unary_function(_Result (*__x)(_Arg))
> : _M_ptr(__x) { }
>
> _Result
> operator()(_Arg __x) const
> { return _M_ptr(__x); }
> };
>
>
> template<typename _Arg, typename _Result>
> inline pointer_to_unary_function<_Arg, _Result>
> ptr_fun(_Result (*__x)(_Arg))
> { return pointer_to_unary_function<_Arg, _Result>(__x); }
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> class pointer_to_binary_function
> : public binary_function<_Arg1, _Arg2, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg1, _Arg2);
>
> public:
> pointer_to_binary_function() { }
>
> explicit
> pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
> : _M_ptr(__x) { }
>
> _Result
> operator()(_Arg1 __x, _Arg2 __y) const
> { return _M_ptr(__x, __y); }
> };
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
> ptr_fun(_Result (*__x)(_Arg1, _Arg2))
> { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
>
>
> template<typename _Tp>
> struct _Identity
> : public unary_function<_Tp, _Tp>
> {
> _Tp&
> operator()(_Tp& __x) const
> { return __x; }
>
> const _Tp&
> operator()(const _Tp& __x) const
> { return __x; }
> };
>
>
> template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
>
> template<typename _Pair>
> struct _Select1st
> : public unary_function<_Pair, typename _Pair::first_type>
> {
> typename _Pair::first_type&
> operator()(_Pair& __x) const
> { return __x.first; }
>
> const typename _Pair::first_type&
> operator()(const _Pair& __x) const
> { return __x.first; }
>
>
> template<typename _Pair2>
> typename _Pair2::first_type&
> operator()(_Pair2& __x) const
> { return __x.first; }
>
> template<typename _Pair2>
> const typename _Pair2::first_type&
> operator()(const _Pair2& __x) const
> { return __x.first; }
>
> };
>
> template<typename _Pair>
> struct _Select2nd
> : public unary_function<_Pair, typename _Pair::second_type>
> {
> typename _Pair::second_type&
> operator()(_Pair& __x) const
> { return __x.second; }
>
> const typename _Pair::second_type&
> operator()(const _Pair& __x) const
> { return __x.second; }
> };
># 1178 "/usr/include/c++/8/bits/stl_function.h" 3
> template<typename _Ret, typename _Tp>
> class mem_fun_t : public unary_function<_Tp*, _Ret>
> {
> public:
> explicit
> mem_fun_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp* __p) const
> { return (__p->*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
> {
> public:
> explicit
> const_mem_fun_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp* __p) const
> { return (__p->*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> mem_fun_ref_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp& __r) const
> { return (__r.*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp& __r) const
> { return (__r.*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template<typename _Ret, typename _Tp>
> inline mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)())
> { return mem_fun_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline const_mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)())
> { return mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline const_mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline const_mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
>
>
>
>}
>
>
># 1 "/usr/include/c++/8/backward/binders.h" 1 3
># 60 "/usr/include/c++/8/backward/binders.h" 3
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 107 "/usr/include/c++/8/backward/binders.h" 3
> template<typename _Operation>
> class binder1st
> : public unary_function<typename _Operation::second_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::first_argument_type value;
>
> public:
> binder1st(const _Operation& __x,
> const typename _Operation::first_argument_type& __y)
> : op(__x), value(__y) { }
>
> typename _Operation::result_type
> operator()(const typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
> } __attribute__ ((__deprecated__));
>
>
> template<typename _Operation, typename _Tp>
> inline binder1st<_Operation>
> bind1st(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::first_argument_type _Arg1_type;
> return binder1st<_Operation>(__fn, _Arg1_type(__x));
> }
>
>
> template<typename _Operation>
> class binder2nd
> : public unary_function<typename _Operation::first_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::second_argument_type value;
>
> public:
> binder2nd(const _Operation& __x,
> const typename _Operation::second_argument_type& __y)
> : op(__x), value(__y) { }
>
> typename _Operation::result_type
> operator()(const typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
> } __attribute__ ((__deprecated__));
>
>
> template<typename _Operation, typename _Tp>
> inline binder2nd<_Operation>
> bind2nd(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::second_argument_type _Arg2_type;
> return binder2nd<_Operation>(__fn, _Arg2_type(__x));
> }
>
>
>
>}
>
>#pragma GCC diagnostic pop
># 1369 "/usr/include/c++/8/bits/stl_function.h" 2 3
># 49 "/usr/include/c++/8/string" 2 3
>
>
># 1 "/usr/include/c++/8/bits/range_access.h" 1 3
># 33 "/usr/include/c++/8/bits/range_access.h" 3
> 
># 34 "/usr/include/c++/8/bits/range_access.h" 3
>
>
># 1 "/usr/include/c++/8/initializer_list" 1 3
># 33 "/usr/include/c++/8/initializer_list" 3
> 
># 34 "/usr/include/c++/8/initializer_list" 3
>
>
>
>
>
>#pragma GCC visibility push(default)
>
>
>
>namespace std
>{
>
> template<class _E>
> class initializer_list
> {
> public:
> typedef _E value_type;
> typedef const _E& reference;
> typedef const _E& const_reference;
> typedef size_t size_type;
> typedef const _E* iterator;
> typedef const _E* const_iterator;
>
> private:
> iterator _M_array;
> size_type _M_len;
>
>
> constexpr initializer_list(const_iterator __a, size_type __l)
> : _M_array(__a), _M_len(__l) { }
>
> public:
> constexpr initializer_list() noexcept
> : _M_array(0), _M_len(0) { }
>
>
> constexpr size_type
> size() const noexcept { return _M_len; }
>
>
> constexpr const_iterator
> begin() const noexcept { return _M_array; }
>
>
> constexpr const_iterator
> end() const noexcept { return begin() + size(); }
> };
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> begin(initializer_list<_Tp> __ils) noexcept
> { return __ils.begin(); }
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> end(initializer_list<_Tp> __ils) noexcept
> { return __ils.end(); }
>}
>
>#pragma GCC visibility pop
># 37 "/usr/include/c++/8/bits/range_access.h" 2 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> begin(_Container& __cont) -> decltype(__cont.begin())
> { return __cont.begin(); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> begin(const _Container& __cont) -> decltype(__cont.begin())
> { return __cont.begin(); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> end(_Container& __cont) -> decltype(__cont.end())
> { return __cont.end(); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> end(const _Container& __cont) -> decltype(__cont.end())
> { return __cont.end(); }
>
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline constexpr _Tp*
> begin(_Tp (&__arr)[_Nm])
> { return __arr; }
>
>
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline constexpr _Tp*
> end(_Tp (&__arr)[_Nm])
> { return __arr + _Nm; }
>
>
>
> template<typename _Tp> class valarray;
>
> template<typename _Tp> _Tp* begin(valarray<_Tp>&);
> template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
> template<typename _Tp> _Tp* end(valarray<_Tp>&);
> template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
> -> decltype(std::begin(__cont))
> { return std::begin(__cont); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
> -> decltype(std::end(__cont))
> { return std::end(__cont); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> rbegin(_Container& __cont) -> decltype(__cont.rbegin())
> { return __cont.rbegin(); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
> { return __cont.rbegin(); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> rend(_Container& __cont) -> decltype(__cont.rend())
> { return __cont.rend(); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> rend(const _Container& __cont) -> decltype(__cont.rend())
> { return __cont.rend(); }
>
>
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline constexpr reverse_iterator<_Tp*>
> rbegin(_Tp (&__arr)[_Nm])
> { return reverse_iterator<_Tp*>(__arr + _Nm); }
>
>
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline constexpr reverse_iterator<_Tp*>
> rend(_Tp (&__arr)[_Nm])
> { return reverse_iterator<_Tp*>(__arr); }
>
>
>
>
>
>
> template<typename _Tp>
> inline constexpr reverse_iterator<const _Tp*>
> rbegin(initializer_list<_Tp> __il)
> { return reverse_iterator<const _Tp*>(__il.end()); }
>
>
>
>
>
>
> template<typename _Tp>
> inline constexpr reverse_iterator<const _Tp*>
> rend(initializer_list<_Tp> __il)
> { return reverse_iterator<const _Tp*>(__il.begin()); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
> { return std::rbegin(__cont); }
>
>
>
>
>
>
> template<typename _Container>
> inline constexpr auto
> crend(const _Container& __cont) -> decltype(std::rend(__cont))
> { return std::rend(__cont); }
># 240 "/usr/include/c++/8/bits/range_access.h" 3
> template <typename _Container>
> constexpr auto
> size(const _Container& __cont) noexcept(noexcept(__cont.size()))
> -> decltype(__cont.size())
> { return __cont.size(); }
>
>
>
>
>
> template <typename _Tp, size_t _Nm>
> constexpr size_t
> size(const _Tp (& )[_Nm]) noexcept
> { return _Nm; }
>
>
>
>
>
> template <typename _Container>
> [[nodiscard]] constexpr auto
> empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
> -> decltype(__cont.empty())
> { return __cont.empty(); }
>
>
>
>
>
> template <typename _Tp, size_t _Nm>
> [[nodiscard]] constexpr bool
> empty(const _Tp (& )[_Nm]) noexcept
> { return false; }
>
>
>
>
>
> template <typename _Tp>
> [[nodiscard]] constexpr bool
> empty(initializer_list<_Tp> __il) noexcept
> { return __il.size() == 0;}
>
>
>
>
>
> template <typename _Container>
> constexpr auto
> data(_Container& __cont) noexcept(noexcept(__cont.data()))
> -> decltype(__cont.data())
> { return __cont.data(); }
>
>
>
>
>
> template <typename _Container>
> constexpr auto
> data(const _Container& __cont) noexcept(noexcept(__cont.data()))
> -> decltype(__cont.data())
> { return __cont.data(); }
>
>
>
>
>
> template <typename _Tp, size_t _Nm>
> constexpr _Tp*
> data(_Tp (&__array)[_Nm]) noexcept
> { return __array; }
>
>
>
>
>
> template <typename _Tp>
> constexpr const _Tp*
> data(initializer_list<_Tp> __il) noexcept
> { return __il.begin(); }
>
>
>
>
>}
># 52 "/usr/include/c++/8/string" 2 3
># 1 "/usr/include/c++/8/bits/basic_string.h" 1 3
># 37 "/usr/include/c++/8/bits/basic_string.h" 3
> 
># 38 "/usr/include/c++/8/bits/basic_string.h" 3
>
>
># 1 "/usr/include/c++/8/ext/alloc_traits.h" 1 3
># 32 "/usr/include/c++/8/ext/alloc_traits.h" 3
> 
># 33 "/usr/include/c++/8/ext/alloc_traits.h" 3
>
>
>
># 1 "/usr/include/c++/8/bits/alloc_traits.h" 1 3
># 41 "/usr/include/c++/8/bits/alloc_traits.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> struct __allocator_traits_base
> {
> template<typename _Tp, typename _Up, typename = void>
> struct __rebind : __replace_first_arg<_Tp, _Up> { };
>
> template<typename _Tp, typename _Up>
> struct __rebind<_Tp, _Up,
> __void_t<typename _Tp::template rebind<_Up>::other>>
> { using type = typename _Tp::template rebind<_Up>::other; };
>
> protected:
> template<typename _Tp>
> using __pointer = typename _Tp::pointer;
> template<typename _Tp>
> using __c_pointer = typename _Tp::const_pointer;
> template<typename _Tp>
> using __v_pointer = typename _Tp::void_pointer;
> template<typename _Tp>
> using __cv_pointer = typename _Tp::const_void_pointer;
> template<typename _Tp>
> using __pocca = typename _Tp::propagate_on_container_copy_assignment;
> template<typename _Tp>
> using __pocma = typename _Tp::propagate_on_container_move_assignment;
> template<typename _Tp>
> using __pocs = typename _Tp::propagate_on_container_swap;
> template<typename _Tp>
> using __equal = typename _Tp::is_always_equal;
> };
>
> template<typename _Alloc, typename _Up>
> using __alloc_rebind
> = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
>
>
>
>
>
> template<typename _Alloc>
> struct allocator_traits : __allocator_traits_base
> {
>
> typedef _Alloc allocator_type;
>
> typedef typename _Alloc::value_type value_type;
>
>
>
>
>
>
> using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
>
> private:
>
> template<template<typename> class _Func, typename _Tp, typename = void>
> struct _Ptr
> {
> using type = typename pointer_traits<pointer>::template rebind<_Tp>;
> };
>
> template<template<typename> class _Func, typename _Tp>
> struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
> {
> using type = _Func<_Alloc>;
> };
>
>
> template<typename _A2, typename _PtrT, typename = void>
> struct _Diff
> { using type = typename pointer_traits<_PtrT>::difference_type; };
>
> template<typename _A2, typename _PtrT>
> struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
> { using type = typename _A2::difference_type; };
>
>
> template<typename _A2, typename _DiffT, typename = void>
> struct _Size : make_unsigned<_DiffT> { };
>
> template<typename _A2, typename _DiffT>
> struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
> { using type = typename _A2::size_type; };
>
> public:
>
>
>
>
>
>
> using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;
>
>
>
>
>
>
>
> using void_pointer = typename _Ptr<__v_pointer, void>::type;
>
>
>
>
>
>
>
> using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;
>
>
>
>
>
>
>
> using difference_type = typename _Diff<_Alloc, pointer>::type;
>
>
>
>
>
>
>
> using size_type = typename _Size<_Alloc, difference_type>::type;
>
>
>
>
>
>
>
> using propagate_on_container_copy_assignment
> = __detected_or_t<false_type, __pocca, _Alloc>;
>
>
>
>
>
>
>
> using propagate_on_container_move_assignment
> = __detected_or_t<false_type, __pocma, _Alloc>;
>
>
>
>
>
>
>
> using propagate_on_container_swap
> = __detected_or_t<false_type, __pocs, _Alloc>;
>
>
>
>
>
>
>
> using is_always_equal
> = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
>
> template<typename _Tp>
> using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
> template<typename _Tp>
> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
>
> private:
> template<typename _Alloc2>
> static auto
> _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
> -> decltype(__a.allocate(__n, __hint))
> { return __a.allocate(__n, __hint); }
>
> template<typename _Alloc2>
> static pointer
> _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
> { return __a.allocate(__n); }
>
> template<typename _Tp, typename... _Args>
> struct __construct_helper
> {
> template<typename _Alloc2,
> typename = decltype(std::declval<_Alloc2*>()->construct(
> std::declval<_Tp*>(), std::declval<_Args>()...))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> using type = decltype(__test<_Alloc>(0));
> };
>
> template<typename _Tp, typename... _Args>
> using __has_construct
> = typename __construct_helper<_Tp, _Args...>::type;
>
> template<typename _Tp, typename... _Args>
> static _Require<__has_construct<_Tp, _Args...>>
> _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
> { __a.construct(__p, std::forward<_Args>(__args)...); }
>
> template<typename _Tp, typename... _Args>
> static
> _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
> is_constructible<_Tp, _Args...>>>
> _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
> { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
>
> template<typename _Alloc2, typename _Tp>
> static auto
> _S_destroy(_Alloc2& __a, _Tp* __p, int)
> -> decltype(__a.destroy(__p))
> { __a.destroy(__p); }
>
> template<typename _Alloc2, typename _Tp>
> static void
> _S_destroy(_Alloc2&, _Tp* __p, ...)
> { __p->~_Tp(); }
>
> template<typename _Alloc2>
> static auto
> _S_max_size(_Alloc2& __a, int)
> -> decltype(__a.max_size())
> { return __a.max_size(); }
>
> template<typename _Alloc2>
> static size_type
> _S_max_size(_Alloc2&, ...)
> {
>
>
> return __gnu_cxx::__numeric_traits<size_type>::__max
> / sizeof(value_type);
> }
>
> template<typename _Alloc2>
> static auto
> _S_select(_Alloc2& __a, int)
> -> decltype(__a.select_on_container_copy_construction())
> { return __a.select_on_container_copy_construction(); }
>
> template<typename _Alloc2>
> static _Alloc2
> _S_select(_Alloc2& __a, ...)
> { return __a; }
>
> public:
># 299 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static pointer
> allocate(_Alloc& __a, size_type __n)
> { return __a.allocate(__n); }
># 314 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static pointer
> allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
> { return _S_allocate(__a, __n, __hint, 0); }
># 326 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static void
> deallocate(_Alloc& __a, pointer __p, size_type __n)
> { __a.deallocate(__p, __n); }
># 341 "/usr/include/c++/8/bits/alloc_traits.h" 3
> template<typename _Tp, typename... _Args>
> static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
> -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
> { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
># 354 "/usr/include/c++/8/bits/alloc_traits.h" 3
> template<typename _Tp>
> static void destroy(_Alloc& __a, _Tp* __p)
> { _S_destroy(__a, __p, 0); }
># 366 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static size_type max_size(const _Alloc& __a) noexcept
> { return _S_max_size(__a, 0); }
># 377 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static _Alloc
> select_on_container_copy_construction(const _Alloc& __rhs)
> { return _S_select(__rhs, 0); }
> };
>
>
> template<typename _Tp>
> struct allocator_traits<allocator<_Tp>>
> {
>
> using allocator_type = allocator<_Tp>;
>
> using value_type = _Tp;
>
>
> using pointer = _Tp*;
>
>
> using const_pointer = const _Tp*;
>
>
> using void_pointer = void*;
>
>
> using const_void_pointer = const void*;
>
>
> using difference_type = std::ptrdiff_t;
>
>
> using size_type = std::size_t;
>
>
> using propagate_on_container_copy_assignment = false_type;
>
>
> using propagate_on_container_move_assignment = true_type;
>
>
> using propagate_on_container_swap = false_type;
>
>
> using is_always_equal = true_type;
>
> template<typename _Up>
> using rebind_alloc = allocator<_Up>;
>
> template<typename _Up>
> using rebind_traits = allocator_traits<allocator<_Up>>;
># 434 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static pointer
> allocate(allocator_type& __a, size_type __n)
> { return __a.allocate(__n); }
># 448 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static pointer
> allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
> { return __a.allocate(__n, __hint); }
># 460 "/usr/include/c++/8/bits/alloc_traits.h" 3
> static void
> deallocate(allocator_type& __a, pointer __p, size_type __n)
> { __a.deallocate(__p, __n); }
># 472 "/usr/include/c++/8/bits/alloc_traits.h" 3
> template<typename _Up, typename... _Args>
> static void
> construct(allocator_type& __a, _Up* __p, _Args&&... __args)
> { __a.construct(__p, std::forward<_Args>(__args)...); }
># 484 "/usr/include/c++/8/bits/alloc_traits.h" 3
> template<typename _Up>
> static void
> destroy(allocator_type& __a, _Up* __p)
> { __a.destroy(__p); }
>
>
>
>
>
>
> static size_type
> max_size(const allocator_type& __a) noexcept
> { return __a.max_size(); }
>
>
>
>
>
>
> static allocator_type
> select_on_container_copy_construction(const allocator_type& __rhs)
> { return __rhs; }
> };
>
>
> template<typename _Alloc>
> inline void
> __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
> { __one = __two; }
>
> template<typename _Alloc>
> inline void
> __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_copy_assignment __pocca;
> __do_alloc_on_copy(__one, __two, __pocca());
> }
>
> template<typename _Alloc>
> inline _Alloc __alloc_on_copy(const _Alloc& __a)
> {
> typedef allocator_traits<_Alloc> __traits;
> return __traits::select_on_container_copy_construction(__a);
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
> { __one = std::move(__two); }
>
> template<typename _Alloc>
> inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_move_assignment __pocma;
> __do_alloc_on_move(__one, __two, __pocma());
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
> {
> using std::swap;
> swap(__one, __two);
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_swap __pocs;
> __do_alloc_on_swap(__one, __two, __pocs());
> }
>
> template<typename _Alloc>
> class __is_copy_insertable_impl
> {
> typedef allocator_traits<_Alloc> _Traits;
>
> template<typename _Up, typename
> = decltype(_Traits::construct(std::declval<_Alloc&>(),
> std::declval<_Up*>(),
> std::declval<const _Up&>()))>
> static true_type
> _M_select(int);
>
> template<typename _Up>
> static false_type
> _M_select(...);
>
> public:
> typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
> };
>
>
> template<typename _Alloc>
> struct __is_copy_insertable
> : __is_copy_insertable_impl<_Alloc>::type
> { };
>
>
> template<typename _Tp>
> struct __is_copy_insertable<allocator<_Tp>>
> : is_copy_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;
>
>
>
>}
># 37 "/usr/include/c++/8/ext/alloc_traits.h" 2 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>template<typename _Alloc, typename = typename _Alloc::value_type>
> struct __alloc_traits
>
> : std::allocator_traits<_Alloc>
>
> {
> typedef _Alloc allocator_type;
>
> typedef std::allocator_traits<_Alloc> _Base_type;
> typedef typename _Base_type::value_type value_type;
> typedef typename _Base_type::pointer pointer;
> typedef typename _Base_type::const_pointer const_pointer;
> typedef typename _Base_type::size_type size_type;
> typedef typename _Base_type::difference_type difference_type;
>
> typedef value_type& reference;
> typedef const value_type& const_reference;
> using _Base_type::allocate;
> using _Base_type::deallocate;
> using _Base_type::construct;
> using _Base_type::destroy;
> using _Base_type::max_size;
>
> private:
> template<typename _Ptr>
> using __is_custom_pointer
> = std::__and_<std::is_same<pointer, _Ptr>,
> std::__not_<std::is_pointer<_Ptr>>>;
>
> public:
>
> template<typename _Ptr, typename... _Args>
> static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
> construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
> {
> _Base_type::construct(__a, std::__to_address(__p),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Ptr>
> static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
> destroy(_Alloc& __a, _Ptr __p)
> { _Base_type::destroy(__a, std::__to_address(__p)); }
>
> static _Alloc _S_select_on_copy(const _Alloc& __a)
> { return _Base_type::select_on_container_copy_construction(__a); }
>
> static void _S_on_swap(_Alloc& __a, _Alloc& __b)
> { std::__alloc_on_swap(__a, __b); }
>
> static constexpr bool _S_propagate_on_copy_assign()
> { return _Base_type::propagate_on_container_copy_assignment::value; }
>
> static constexpr bool _S_propagate_on_move_assign()
> { return _Base_type::propagate_on_container_move_assignment::value; }
>
> static constexpr bool _S_propagate_on_swap()
> { return _Base_type::propagate_on_container_swap::value; }
>
> static constexpr bool _S_always_equal()
> { return _Base_type::is_always_equal::value; }
>
> static constexpr bool _S_nothrow_move()
> { return _S_propagate_on_move_assign() || _S_always_equal(); }
>
> template<typename _Tp>
> struct rebind
> { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
># 158 "/usr/include/c++/8/ext/alloc_traits.h" 3
> };
>
>
>}
># 41 "/usr/include/c++/8/bits/basic_string.h" 2 3
>
>
>
>
>
>
>
># 1 "/usr/include/c++/8/string_view" 1 3
># 36 "/usr/include/c++/8/string_view" 3
> 
># 37 "/usr/include/c++/8/string_view" 3
>
>
>
># 1 "/usr/include/c++/8/limits" 1 3
># 40 "/usr/include/c++/8/limits" 3
> 
># 41 "/usr/include/c++/8/limits" 3
># 158 "/usr/include/c++/8/limits" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> enum float_round_style
> {
> round_indeterminate = -1,
> round_toward_zero = 0,
> round_to_nearest = 1,
> round_toward_infinity = 2,
> round_toward_neg_infinity = 3
> };
>
>
>
>
>
>
>
> enum float_denorm_style
> {
>
> denorm_indeterminate = -1,
>
> denorm_absent = 0,
>
> denorm_present = 1
> };
># 202 "/usr/include/c++/8/limits" 3
> struct __numeric_limits_base
> {
>
>
> static constexpr bool is_specialized = false;
>
>
>
>
> static constexpr int digits = 0;
>
>
> static constexpr int digits10 = 0;
>
>
>
>
> static constexpr int max_digits10 = 0;
>
>
>
> static constexpr bool is_signed = false;
>
>
> static constexpr bool is_integer = false;
>
>
>
>
> static constexpr bool is_exact = false;
>
>
>
> static constexpr int radix = 0;
>
>
>
> static constexpr int min_exponent = 0;
>
>
>
> static constexpr int min_exponent10 = 0;
>
>
>
>
> static constexpr int max_exponent = 0;
>
>
>
> static constexpr int max_exponent10 = 0;
>
>
> static constexpr bool has_infinity = false;
>
>
>
> static constexpr bool has_quiet_NaN = false;
>
>
>
> static constexpr bool has_signaling_NaN = false;
>
>
> static constexpr float_denorm_style has_denorm = denorm_absent;
>
>
>
> static constexpr bool has_denorm_loss = false;
>
>
>
> static constexpr bool is_iec559 = false;
>
>
>
>
> static constexpr bool is_bounded = false;
># 288 "/usr/include/c++/8/limits" 3
> static constexpr bool is_modulo = false;
>
>
> static constexpr bool traps = false;
>
>
> static constexpr bool tinyness_before = false;
>
>
>
>
> static constexpr float_round_style round_style =
> round_toward_zero;
> };
># 311 "/usr/include/c++/8/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> { };
># 382 "/usr/include/c++/8/limits" 3
> template<>
> struct numeric_limits<bool>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr bool
> min() noexcept { return false; }
>
> static constexpr bool
> max() noexcept { return true; }
>
>
> static constexpr bool
> lowest() noexcept { return min(); }
>
> static constexpr int digits = 1;
> static constexpr int digits10 = 0;
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr bool
> epsilon() noexcept { return false; }
>
> static constexpr bool
> round_error() noexcept { return false; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr bool
> infinity() noexcept { return false; }
>
> static constexpr bool
> quiet_NaN() noexcept { return false; }
>
> static constexpr bool
> signaling_NaN() noexcept { return false; }
>
> static constexpr bool
> denorm_min() noexcept { return false; }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
>
>
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char
> min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
>
> static constexpr char
> max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
>
>
> static constexpr char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = ((char)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char
> epsilon() noexcept { return 0; }
>
> static constexpr char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr
> char infinity() noexcept { return char(); }
>
> static constexpr char
> quiet_NaN() noexcept { return char(); }
>
> static constexpr char
> signaling_NaN() noexcept { return char(); }
>
> static constexpr char
> denorm_min() noexcept { return static_cast<char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<signed char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr signed char
> min() noexcept { return -0x7f - 1; }
>
> static constexpr signed char
> max() noexcept { return 0x7f; }
>
>
> static constexpr signed char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr signed char
> epsilon() noexcept { return 0; }
>
> static constexpr signed char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr signed char
> infinity() noexcept { return static_cast<signed char>(0); }
>
> static constexpr signed char
> quiet_NaN() noexcept { return static_cast<signed char>(0); }
>
> static constexpr signed char
> signaling_NaN() noexcept
> { return static_cast<signed char>(0); }
>
> static constexpr signed char
> denorm_min() noexcept
> { return static_cast<signed char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned char
> min() noexcept { return 0; }
>
> static constexpr unsigned char
> max() noexcept { return 0x7f * 2U + 1; }
>
>
> static constexpr unsigned char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned char
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned char
> infinity() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> quiet_NaN() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> signaling_NaN() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> denorm_min() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<wchar_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr wchar_t
> min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
>
> static constexpr wchar_t
> max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
>
>
> static constexpr wchar_t
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = ((wchar_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr wchar_t
> epsilon() noexcept { return 0; }
>
> static constexpr wchar_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr wchar_t
> infinity() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> quiet_NaN() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> signaling_NaN() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> denorm_min() noexcept { return wchar_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
>
> template<>
> struct numeric_limits<char16_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char16_t
> min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
>
> static constexpr char16_t
> max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
>
> static constexpr char16_t
> lowest() noexcept { return min(); }
>
> static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
> static constexpr int max_digits10 = 0;
> static constexpr bool is_signed = ((char16_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char16_t
> epsilon() noexcept { return 0; }
>
> static constexpr char16_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr char16_t
> infinity() noexcept { return char16_t(); }
>
> static constexpr char16_t
> quiet_NaN() noexcept { return char16_t(); }
>
> static constexpr char16_t
> signaling_NaN() noexcept { return char16_t(); }
>
> static constexpr char16_t
> denorm_min() noexcept { return char16_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char32_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char32_t
> min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
>
> static constexpr char32_t
> max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
>
> static constexpr char32_t
> lowest() noexcept { return min(); }
>
> static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
> static constexpr int max_digits10 = 0;
> static constexpr bool is_signed = ((char32_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char32_t
> epsilon() noexcept { return 0; }
>
> static constexpr char32_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr char32_t
> infinity() noexcept { return char32_t(); }
>
> static constexpr char32_t
> quiet_NaN() noexcept { return char32_t(); }
>
> static constexpr char32_t
> signaling_NaN() noexcept { return char32_t(); }
>
> static constexpr char32_t
> denorm_min() noexcept { return char32_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = !is_signed;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style = round_toward_zero;
> };
>
>
>
> template<>
> struct numeric_limits<short>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr short
> min() noexcept { return -0x7fff - 1; }
>
> static constexpr short
> max() noexcept { return 0x7fff; }
>
>
> static constexpr short
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
> static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr short
> epsilon() noexcept { return 0; }
>
> static constexpr short
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr short
> infinity() noexcept { return short(); }
>
> static constexpr short
> quiet_NaN() noexcept { return short(); }
>
> static constexpr short
> signaling_NaN() noexcept { return short(); }
>
> static constexpr short
> denorm_min() noexcept { return short(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned short>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned short
> min() noexcept { return 0; }
>
> static constexpr unsigned short
> max() noexcept { return 0x7fff * 2U + 1; }
>
>
> static constexpr unsigned short
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned short
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned short
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned short
> infinity() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> quiet_NaN() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> signaling_NaN() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> denorm_min() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<int>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr int
> min() noexcept { return -0x7fffffff - 1; }
>
> static constexpr int
> max() noexcept { return 0x7fffffff; }
>
>
> static constexpr int
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
> static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr int
> epsilon() noexcept { return 0; }
>
> static constexpr int
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr int
> infinity() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> quiet_NaN() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> signaling_NaN() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> denorm_min() noexcept { return static_cast<int>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned int>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned int
> min() noexcept { return 0; }
>
> static constexpr unsigned int
> max() noexcept { return 0x7fffffff * 2U + 1; }
>
>
> static constexpr unsigned int
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned int
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned int
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned int
> infinity() noexcept { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> quiet_NaN() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> signaling_NaN() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> denorm_min() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long
> min() noexcept { return -0x7fffffffffffffffL - 1; }
>
> static constexpr long
> max() noexcept { return 0x7fffffffffffffffL; }
>
>
> static constexpr long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
> static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr long
> epsilon() noexcept { return 0; }
>
> static constexpr long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr long
> infinity() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> quiet_NaN() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> signaling_NaN() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> denorm_min() noexcept { return static_cast<long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned long
> min() noexcept { return 0; }
>
> static constexpr unsigned long
> max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
>
>
> static constexpr unsigned long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned long
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned long
> infinity() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> quiet_NaN() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> signaling_NaN() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> denorm_min() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long long
> min() noexcept { return -0x7fffffffffffffffLL - 1; }
>
> static constexpr long long
> max() noexcept { return 0x7fffffffffffffffLL; }
>
>
> static constexpr long long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(long long) * 8 - ((long long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr long long
> epsilon() noexcept { return 0; }
>
> static constexpr long long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr long long
> infinity() noexcept { return static_cast<long long>(0); }
>
> static constexpr long long
> quiet_NaN() noexcept { return static_cast<long long>(0); }
>
> static constexpr long long
> signaling_NaN() noexcept
> { return static_cast<long long>(0); }
>
> static constexpr long long
> denorm_min() noexcept { return static_cast<long long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned long long
> min() noexcept { return 0; }
>
> static constexpr unsigned long long
> max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
>
>
> static constexpr unsigned long long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned long long
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned long long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned long long
> infinity() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> quiet_NaN() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> signaling_NaN() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> denorm_min() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
># 1593 "/usr/include/c++/8/limits" 3
> template<>
> struct numeric_limits<float>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr float
> min() noexcept { return 1.17549435082228750796873653722224568e-38F; }
>
> static constexpr float
> max() noexcept { return 3.40282346638528859811704183484516925e+38F; }
>
>
> static constexpr float
> lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; }
>
>
> static constexpr int digits = 24;
> static constexpr int digits10 = 6;
>
> static constexpr int max_digits10
> = (2 + (24) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr float
> epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; }
>
> static constexpr float
> round_error() noexcept { return 0.5F; }
>
> static constexpr int min_exponent = (-125);
> static constexpr int min_exponent10 = (-37);
> static constexpr int max_exponent = 128;
> static constexpr int max_exponent10 = 38;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr float
> infinity() noexcept { return __builtin_huge_valf(); }
>
> static constexpr float
> quiet_NaN() noexcept { return __builtin_nanf(""); }
>
> static constexpr float
> signaling_NaN() noexcept { return __builtin_nansf(""); }
>
> static constexpr float
> denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before
> = false;
> static constexpr float_round_style round_style
> = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<double>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr double
> min() noexcept { return double(2.22507385850720138309023271733240406e-308L); }
>
> static constexpr double
> max() noexcept { return double(1.79769313486231570814527423731704357e+308L); }
>
>
> static constexpr double
> lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); }
>
>
> static constexpr int digits = 53;
> static constexpr int digits10 = 15;
>
> static constexpr int max_digits10
> = (2 + (53) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr double
> epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); }
>
> static constexpr double
> round_error() noexcept { return 0.5; }
>
> static constexpr int min_exponent = (-1021);
> static constexpr int min_exponent10 = (-307);
> static constexpr int max_exponent = 1024;
> static constexpr int max_exponent10 = 308;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr double
> infinity() noexcept { return __builtin_huge_val(); }
>
> static constexpr double
> quiet_NaN() noexcept { return __builtin_nan(""); }
>
> static constexpr double
> signaling_NaN() noexcept { return __builtin_nans(""); }
>
> static constexpr double
> denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before
> = false;
> static constexpr float_round_style round_style
> = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<long double>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long double
> min() noexcept { return 3.36210314311209350626267781732175260e-4932L; }
>
> static constexpr long double
> max() noexcept { return 1.18973149535723176502126385303097021e+4932L; }
>
>
> static constexpr long double
> lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; }
>
>
> static constexpr int digits = 64;
> static constexpr int digits10 = 18;
>
> static constexpr int max_digits10
> = (2 + (64) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr long double
> epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; }
>
> static constexpr long double
> round_error() noexcept { return 0.5L; }
>
> static constexpr int min_exponent = (-16381);
> static constexpr int min_exponent10 = (-4931);
> static constexpr int max_exponent = 16384;
> static constexpr int max_exponent10 = 4932;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr long double
> infinity() noexcept { return __builtin_huge_vall(); }
>
> static constexpr long double
> quiet_NaN() noexcept { return __builtin_nanl(""); }
>
> static constexpr long double
> signaling_NaN() noexcept { return __builtin_nansl(""); }
>
> static constexpr long double
> denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before =
> false;
> static constexpr float_round_style round_style =
> round_to_nearest;
> };
>
>
>
>
>
>
>}
># 41 "/usr/include/c++/8/string_view" 2 3
>
>
># 1 "/usr/include/c++/8/bits/functional_hash.h" 1 3
># 33 "/usr/include/c++/8/bits/functional_hash.h" 3
> 
># 34 "/usr/include/c++/8/bits/functional_hash.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 49 "/usr/include/c++/8/bits/functional_hash.h" 3
> template<typename _Result, typename _Arg>
> struct __hash_base
> {
> typedef _Result result_type [[__deprecated__]];
> typedef _Arg argument_type [[__deprecated__]];
> };
>
>
> template<typename _Tp>
> struct hash;
>
> template<typename _Tp, typename = void>
> struct __poison_hash
> {
> static constexpr bool __enable_hash_call = false;
> private:
>
> __poison_hash(__poison_hash&&);
> ~__poison_hash();
> };
>
> template<typename _Tp>
> struct __poison_hash<_Tp, __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
> {
> static constexpr bool __enable_hash_call = true;
> };
>
>
> template<typename _Tp, bool = is_enum<_Tp>::value>
> struct __hash_enum
> {
> private:
>
> __hash_enum(__hash_enum&&);
> ~__hash_enum();
> };
>
>
> template<typename _Tp>
> struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
> {
> size_t
> operator()(_Tp __val) const noexcept
> {
> using __type = typename underlying_type<_Tp>::type;
> return hash<__type>{}(static_cast<__type>(__val));
> }
> };
>
>
>
> template<typename _Tp>
> struct hash : __hash_enum<_Tp>
> { };
>
>
> template<typename _Tp>
> struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
> {
> size_t
> operator()(_Tp* __p) const noexcept
> { return reinterpret_cast<size_t>(__p); }
> };
># 124 "/usr/include/c++/8/bits/functional_hash.h" 3
> template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
># 187 "/usr/include/c++/8/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<typename _Hash>
> struct __is_fast_hash : public std::true_type
> { };
>
> template<>
> struct __is_fast_hash<hash<long double>> : public std::false_type
> { };
>
>
>}
># 44 "/usr/include/c++/8/string_view" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 70 "/usr/include/c++/8/string_view" 3
> template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
> class basic_string_view
> {
> public:
>
>
> using traits_type = _Traits;
> using value_type = _CharT;
> using pointer = const _CharT*;
> using const_pointer = const _CharT*;
> using reference = const _CharT&;
> using const_reference = const _CharT&;
> using const_iterator = const _CharT*;
> 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;
>
> constexpr basic_string_view(const _CharT* __str) noexcept
> : _M_len{__str == nullptr ? 0 : traits_type::length(__str)},
> _M_str{__str}
> { }
>
> constexpr
> basic_string_view(const _CharT* __str, size_type __len) noexcept
> : _M_len{__len}, _M_str{__str}
> { }
>
> constexpr basic_string_view&
> operator=(const basic_string_view&) noexcept = default;
>
>
>
> constexpr const_iterator
> begin() const noexcept
> { return this->_M_str; }
>
> constexpr const_iterator
> end() const noexcept
> { return this->_M_str + this->_M_len; }
>
> constexpr const_iterator
> cbegin() const noexcept
> { return this->_M_str; }
>
> constexpr const_iterator
> cend() const noexcept
> { return this->_M_str + this->_M_len; }
>
> constexpr const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
> constexpr const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
> constexpr const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
> constexpr const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
>
> constexpr size_type
> size() const noexcept
> { return this->_M_len; }
>
> constexpr size_type
> length() const noexcept
> { return _M_len; }
>
> constexpr size_type
> max_size() const noexcept
> {
> return (npos - sizeof(size_type) - sizeof(void*))
> / sizeof(value_type) / 4;
> }
>
> [[nodiscard]] constexpr bool
> empty() const noexcept
> { return this->_M_len == 0; }
>
>
>
> constexpr const _CharT&
> operator[](size_type __pos) const noexcept
> {
>
>
> return *(this->_M_str + __pos);
> }
>
> constexpr const _CharT&
> at(size_type __pos) const
> {
> if (__pos >= _M_len)
> __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)")
>
> , __pos, this->size());
> return *(this->_M_str + __pos);
> }
>
> constexpr const _CharT&
> front() const noexcept
> {
>
>
> return *this->_M_str;
> }
>
> constexpr const _CharT&
> back() const noexcept
> {
>
>
> return *(this->_M_str + this->_M_len - 1);
> }
>
> constexpr const _CharT*
> data() const noexcept
> { return this->_M_str; }
>
>
>
> constexpr void
> remove_prefix(size_type __n) noexcept
> {
> ;
> this->_M_str += __n;
> this->_M_len -= __n;
> }
>
> constexpr void
> remove_suffix(size_type __n) noexcept
> { this->_M_len -= __n; }
>
> constexpr void
> swap(basic_string_view& __sv) noexcept
> {
> auto __tmp = *this;
> *this = __sv;
> __sv = __tmp;
> }
>
>
>
>
> size_type
> copy(_CharT* __str, size_type __n, size_type __pos = 0) const
> {
> ;
> __pos = _M_check(__pos, "basic_string_view::copy");
> const size_type __rlen = std::min(__n, _M_len - __pos);
> for (auto __begin = this->_M_str + __pos,
> __end = __begin + __rlen; __begin != __end;)
> *__str++ = *__begin++;
> return __rlen;
> }
>
> constexpr basic_string_view
> substr(size_type __pos, size_type __n = npos) const noexcept(false)
> {
> __pos = _M_check(__pos, "basic_string_view::substr");
> const size_type __rlen = std::min(__n, _M_len - __pos);
> return basic_string_view{_M_str + __pos, __rlen};
> }
>
> constexpr int
> compare(basic_string_view __str) const noexcept
> {
> const size_type __rlen = std::min(this->_M_len, __str._M_len);
> int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
> if (__ret == 0)
> __ret = _S_compare(this->_M_len, __str._M_len);
> return __ret;
> }
>
> constexpr int
> compare(size_type __pos1, size_type __n1, basic_string_view __str) const
> { return this->substr(__pos1, __n1).compare(__str); }
>
> constexpr int
> compare(size_type __pos1, size_type __n1,
> basic_string_view __str, size_type __pos2, size_type __n2) const
> {
> return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
> }
>
> constexpr int
> compare(const _CharT* __str) const noexcept
> { return this->compare(basic_string_view{__str}); }
>
> constexpr int
> compare(size_type __pos1, size_type __n1, const _CharT* __str) const
> { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
>
> constexpr int
> compare(size_type __pos1, size_type __n1,
> const _CharT* __str, size_type __n2) const noexcept(false)
> {
> return this->substr(__pos1, __n1)
> .compare(basic_string_view(__str, __n2));
> }
>
> constexpr size_type
> find(basic_string_view __str, size_type __pos = 0) const noexcept
> { return this->find(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find(_CharT __c, size_type __pos = 0) const noexcept;
>
> constexpr size_type
> find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
>
> constexpr size_type
> find(const _CharT* __str, size_type __pos = 0) const noexcept
> { return this->find(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> rfind(basic_string_view __str, size_type __pos = npos) const noexcept
> { return this->rfind(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> rfind(_CharT __c, size_type __pos = npos) const noexcept;
>
> constexpr size_type
> rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
>
> constexpr size_type
> rfind(const _CharT* __str, size_type __pos = npos) const noexcept
> { return this->rfind(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
> { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_first_of(_CharT __c, size_type __pos = 0) const noexcept
> { return this->find(__c, __pos); }
>
> constexpr size_type
> find_first_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
>
> constexpr size_type
> find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
> { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> find_last_of(basic_string_view __str,
> size_type __pos = npos) const noexcept
> { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_last_of(_CharT __c, size_type __pos=npos) const noexcept
> { return this->rfind(__c, __pos); }
>
> constexpr size_type
> find_last_of(const _CharT* __str, size_type __pos,
> size_type __n) const noexcept;
>
> constexpr size_type
> find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
> { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> find_first_not_of(basic_string_view __str,
> size_type __pos = 0) const noexcept
> { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
>
> constexpr size_type
> find_first_not_of(const _CharT* __str,
> size_type __pos, size_type __n) const noexcept;
>
> constexpr size_type
> find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
> {
> return this->find_first_not_of(__str, __pos,
> traits_type::length(__str));
> }
>
> constexpr size_type
> find_last_not_of(basic_string_view __str,
> size_type __pos = npos) const noexcept
> { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
>
> constexpr size_type
> find_last_not_of(const _CharT* __str,
> size_type __pos, size_type __n) const noexcept;
>
> 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));
> }
>
> constexpr size_type
> _M_check(size_type __pos, const char* __s) const noexcept(false)
> {
> 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 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;
> }
>
> private:
>
> static constexpr int
> _S_compare(size_type __n1, size_type __n2) noexcept
> {
> const difference_type __diff = __n1 - __n2;
> if (__diff > std::numeric_limits<int>::max())
> return std::numeric_limits<int>::max();
> if (__diff < std::numeric_limits<int>::min())
> return std::numeric_limits<int>::min();
> return static_cast<int>(__diff);
> }
>
> size_t _M_len;
> const _CharT* _M_str;
> };
>
>
>
> namespace __detail
> {
>
>
>
> template<typename _Tp>
> using __idt = common_type_t<_Tp>;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator==(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.size() == __y.size() && __x.compare(__y) == 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator==(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.size() == __y.size() && __x.compare(__y) == 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator==(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.size() == __y.size() && __x.compare(__y) == 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator!=(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return !(__x == __y); }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator!=(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return !(__x == __y); }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator!=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return !(__x == __y); }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator< (basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) < 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator< (basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) < 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator< (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) < 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator> (basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) > 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator> (basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) > 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) > 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator<=(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) <= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator<=(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) <= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator<=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) <= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator>=(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) >= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator>=(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) >= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator>=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) >= 0; }
>
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os,
> basic_string_view<_CharT,_Traits> __str)
> { return __ostream_insert(__os, __str.data(), __str.size()); }
>
>
>
>
> using string_view = basic_string_view<char>;
>
> using wstring_view = basic_string_view<wchar_t>;
>
>
> using u16string_view = basic_string_view<char16_t>;
> using u32string_view = basic_string_view<char32_t>;
>
>
>
>
> template<typename _Tp>
> struct hash;
>
> template<>
> struct hash<string_view>
> : public __hash_base<size_t, string_view>
> {
> size_t
> operator()(const string_view& __str) const noexcept
> { return std::_Hash_impl::hash(__str.data(), __str.length()); }
> };
>
> template<>
> struct __is_fast_hash<hash<string_view>> : std::false_type
> { };
>
>
> template<>
> struct hash<wstring_view>
> : public __hash_base<size_t, wstring>
> {
> 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<u16string_view>
> : public __hash_base<size_t, u16string_view>
> {
> size_t
> operator()(const u16string_view& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char16_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<u16string_view>> : std::false_type
> { };
>
> template<>
> struct hash<u32string_view>
> : public __hash_base<size_t, u32string_view>
> {
> size_t
> operator()(const u32string_view& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char32_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<u32string_view>> : std::false_type
> { };
>
>
> inline namespace literals
> {
> inline namespace string_view_literals
> {
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wliteral-suffix"
> inline constexpr basic_string_view<char>
> operator""sv(const char* __str, size_t __len) noexcept
> { return basic_string_view<char>{__str, __len}; }
>
>
> inline constexpr basic_string_view<wchar_t>
> operator""sv(const wchar_t* __str, size_t __len) noexcept
> { return basic_string_view<wchar_t>{__str, __len}; }
>
>
>
> 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
> }
> }
>
>
>}
>
># 1 "/usr/include/c++/8/bits/string_view.tcc" 1 3
># 37 "/usr/include/c++/8/bits/string_view.tcc" 3
> 
># 38 "/usr/include/c++/8/bits/string_view.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
> {
> ;
>
> if (__n == 0)
> return __pos <= this->_M_len ? __pos : npos;
>
> if (__n <= this->_M_len)
> {
> for (; __pos <= this->_M_len - __n; ++__pos)
> if (traits_type::eq(this->_M_str[__pos], __str[0])
> && traits_type::compare(this->_M_str + __pos + 1,
> __str + 1, __n - 1) == 0)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find(_CharT __c, size_type __pos) const noexcept
> {
> size_type __ret = npos;
> if (__pos < this->_M_len)
> {
> const size_type __n = this->_M_len - __pos;
> const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
> if (__p)
> __ret = __p - this->_M_str;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
> {
> ;
>
> if (__n <= this->_M_len)
> {
> __pos = std::min(size_type(this->_M_len - __n), __pos);
> do
> {
> if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
> return __pos;
> }
> while (__pos-- > 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> rfind(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->_M_len;
> if (__size > 0)
> {
> if (--__size > __pos)
> __size = __pos;
> for (++__size; __size-- > 0; )
> if (traits_type::eq(this->_M_str[__size], __c))
> return __size;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_first_of(const _CharT* __str, size_type __pos,
> size_type __n) const noexcept
> {
> ;
> for (; __n && __pos < this->_M_len; ++__pos)
> {
> const _CharT* __p = traits_type::find(__str, __n,
> this->_M_str[__pos]);
> if (__p)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_last_of(const _CharT* __str, size_type __pos,
> size_type __n) const noexcept
> {
> ;
> size_type __size = this->size();
> if (__size && __n)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (traits_type::find(__str, __n, this->_M_str[__size]))
> return __size;
> }
> while (__size-- != 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_first_not_of(const _CharT* __str, size_type __pos,
> size_type __n) const noexcept
> {
> ;
> for (; __pos < this->_M_len; ++__pos)
> if (!traits_type::find(__str, __n, this->_M_str[__pos]))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_first_not_of(_CharT __c, size_type __pos) const noexcept
> {
> for (; __pos < this->_M_len; ++__pos)
> if (!traits_type::eq(this->_M_str[__pos], __c))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_last_not_of(const _CharT* __str, size_type __pos,
> size_type __n) const noexcept
> {
> ;
> size_type __size = this->_M_len;
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::find(__str, __n, this->_M_str[__size]))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_last_not_of(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->_M_len;
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::eq(this->_M_str[__size], __c))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
>
>}
># 658 "/usr/include/c++/8/string_view" 2 3
># 49 "/usr/include/c++/8/bits/basic_string.h" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>namespace __cxx11 {
># 76 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_string
> {
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<_CharT>::other _Char_alloc_type;
> typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
>
>
> public:
> typedef _Traits traits_type;
> typedef typename _Traits::char_type value_type;
> typedef _Char_alloc_type allocator_type;
> typedef typename _Alloc_traits::size_type size_type;
> typedef typename _Alloc_traits::difference_type difference_type;
> typedef typename _Alloc_traits::reference reference;
> typedef typename _Alloc_traits::const_reference const_reference;
> typedef typename _Alloc_traits::pointer pointer;
> typedef typename _Alloc_traits::const_pointer const_pointer;
> typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
>
>
> static const size_type npos = static_cast<size_type>(-1);
>
> private:
>
>
>
>
> typedef const_iterator __const_iterator;
>
>
>
>
> typedef basic_string_view<_CharT, _Traits> __sv_type;
>
> template<typename _Tp, typename _Res>
> using _If_sv = enable_if_t<
> __and_<is_convertible<const _Tp&, __sv_type>,
> __not_<is_convertible<const _Tp*, const basic_string*>>,
> __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
> _Res>;
>
>
> static __sv_type
> _S_to_string_view(__sv_type __svt) noexcept
> { return __svt; }
>
>
>
>
>
> struct __sv_wrapper
> {
> explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
> __sv_type _M_sv;
> };
>
>
>
> struct _Alloc_hider : allocator_type
> {
>
>
>
>
> _Alloc_hider(pointer __dat, const _Alloc& __a)
> : allocator_type(__a), _M_p(__dat) { }
>
> _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
> : allocator_type(std::move(__a)), _M_p(__dat) { }
>
>
> pointer _M_p;
> };
>
> _Alloc_hider _M_dataplus;
> size_type _M_string_length;
>
> enum { _S_local_capacity = 15 / sizeof(_CharT) };
>
> union
> {
> _CharT _M_local_buf[_S_local_capacity + 1];
> size_type _M_allocated_capacity;
> };
>
> void
> _M_data(pointer __p)
> { _M_dataplus._M_p = __p; }
>
> void
> _M_length(size_type __length)
> { _M_string_length = __length; }
>
> pointer
> _M_data() const
> { return _M_dataplus._M_p; }
>
> pointer
> _M_local_data()
> {
>
> return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
>
>
>
> }
>
> const_pointer
> _M_local_data() const
> {
>
> return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
>
>
>
> }
>
> void
> _M_capacity(size_type __capacity)
> { _M_allocated_capacity = __capacity; }
>
> void
> _M_set_length(size_type __n)
> {
> _M_length(__n);
> traits_type::assign(_M_data()[__n], _CharT());
> }
>
> bool
> _M_is_local() const
> { return _M_data() == _M_local_data(); }
>
>
> pointer
> _M_create(size_type&, size_type);
>
> void
> _M_dispose()
> {
> if (!_M_is_local())
> _M_destroy(_M_allocated_capacity);
> }
>
> void
> _M_destroy(size_type __size) throw()
> { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
>
>
>
> template<typename _InIterator>
> void
> _M_construct_aux(_InIterator __beg, _InIterator __end,
> std::__false_type)
> {
> typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
> _M_construct(__beg, __end, _Tag());
> }
>
>
>
> template<typename _Integer>
> void
> _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
> { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
>
> void
> _M_construct_aux_2(size_type __req, _CharT __c)
> { _M_construct(__req, __c); }
>
> template<typename _InIterator>
> void
> _M_construct(_InIterator __beg, _InIterator __end)
> {
> typedef typename std::__is_integer<_InIterator>::__type _Integral;
> _M_construct_aux(__beg, __end, _Integral());
> }
>
>
> template<typename _InIterator>
> void
> _M_construct(_InIterator __beg, _InIterator __end,
> std::input_iterator_tag);
>
>
>
> template<typename _FwdIterator>
> void
> _M_construct(_FwdIterator __beg, _FwdIterator __end,
> std::forward_iterator_tag);
>
> void
> _M_construct(size_type __req, _CharT __c);
>
> allocator_type&
> _M_get_allocator()
> { return _M_dataplus; }
>
> const allocator_type&
> _M_get_allocator() const
> { return _M_dataplus; }
>
> private:
># 298 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> _M_check(size_type __pos, const char* __s) const
> {
> if (__pos > this->size())
> __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)")
> ,
> __s, __pos, this->size());
> return __pos;
> }
>
> void
> _M_check_length(size_type __n1, size_type __n2, const char* __s) const
> {
> if (this->max_size() - (this->size() - __n1) < __n2)
> __throw_length_error((__s));
> }
>
>
>
> size_type
> _M_limit(size_type __pos, size_type __off) const noexcept
> {
> const bool __testoff = __off < this->size() - __pos;
> return __testoff ? __off : this->size() - __pos;
> }
>
>
> bool
> _M_disjunct(const _CharT* __s) const noexcept
> {
> return (less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s));
> }
>
>
>
> static void
> _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
> {
> if (__n == 1)
> traits_type::assign(*__d, *__s);
> else
> traits_type::copy(__d, __s, __n);
> }
>
> static void
> _S_move(_CharT* __d, const _CharT* __s, size_type __n)
> {
> if (__n == 1)
> traits_type::assign(*__d, *__s);
> else
> traits_type::move(__d, __s, __n);
> }
>
> static void
> _S_assign(_CharT* __d, size_type __n, _CharT __c)
> {
> if (__n == 1)
> traits_type::assign(*__d, __c);
> else
> traits_type::assign(__d, __n, __c);
> }
>
>
>
> template<class _Iterator>
> static void
> _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
> {
> for (; __k1 != __k2; ++__k1, (void)++__p)
> traits_type::assign(*__p, *__k1);
> }
>
> static void
> _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
> noexcept
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
> { _S_copy(__p, __k1, __k2 - __k1); }
>
> static void
> _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
> noexcept
> { _S_copy(__p, __k1, __k2 - __k1); }
>
> static int
> _S_compare(size_type __n1, size_type __n2) noexcept
> {
> const difference_type __d = difference_type(__n1 - __n2);
>
> if (__d > __gnu_cxx::__numeric_traits<int>::__max)
> return __gnu_cxx::__numeric_traits<int>::__max;
> else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
> return __gnu_cxx::__numeric_traits<int>::__min;
> else
> return int(__d);
> }
>
> void
> _M_assign(const basic_string&);
>
> void
> _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
> size_type __len2);
>
> void
> _M_erase(size_type __pos, size_type __n);
>
> public:
>
>
>
>
>
>
>
> basic_string()
> noexcept(is_nothrow_default_constructible<_Alloc>::value)
> : _M_dataplus(_M_local_data())
> { _M_set_length(0); }
>
>
>
>
> explicit
> basic_string(const _Alloc& __a) noexcept
> : _M_dataplus(_M_local_data(), __a)
> { _M_set_length(0); }
>
>
>
>
>
> basic_string(const basic_string& __str)
> : _M_dataplus(_M_local_data(),
> _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
> { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
># 450 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string(const basic_string& __str, size_type __pos,
> const _Alloc& __a = _Alloc())
> : _M_dataplus(_M_local_data(), __a)
> {
> const _CharT* __start = __str._M_data()
> + __str._M_check(__pos, "basic_string::basic_string");
> _M_construct(__start, __start + __str._M_limit(__pos, npos));
> }
>
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n)
> : _M_dataplus(_M_local_data())
> {
> const _CharT* __start = __str._M_data()
> + __str._M_check(__pos, "basic_string::basic_string");
> _M_construct(__start, __start + __str._M_limit(__pos, __n));
> }
># 481 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a)
> : _M_dataplus(_M_local_data(), __a)
> {
> const _CharT* __start
> = __str._M_data() + __str._M_check(__pos, "string::string");
> _M_construct(__start, __start + __str._M_limit(__pos, __n));
> }
># 499 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string(const _CharT* __s, size_type __n,
> const _Alloc& __a = _Alloc())
> : _M_dataplus(_M_local_data(), __a)
> { _M_construct(__s, __s + __n); }
>
>
>
>
>
>
> basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
> : _M_dataplus(_M_local_data(), __a)
> { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
>
>
>
>
>
>
>
> basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
> : _M_dataplus(_M_local_data(), __a)
> { _M_construct(__n, __c); }
># 531 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string(basic_string&& __str) noexcept
> : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
> {
> if (__str._M_is_local())
> {
> traits_type::copy(_M_local_buf, __str._M_local_buf,
> _S_local_capacity + 1);
> }
> else
> {
> _M_data(__str._M_data());
> _M_capacity(__str._M_allocated_capacity);
> }
>
>
>
>
> _M_length(__str.length());
> __str._M_data(__str._M_local_data());
> __str._M_set_length(0);
> }
>
>
>
>
>
>
> basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
> : _M_dataplus(_M_local_data(), __a)
> { _M_construct(__l.begin(), __l.end()); }
>
> basic_string(const basic_string& __str, const _Alloc& __a)
> : _M_dataplus(_M_local_data(), __a)
> { _M_construct(__str.begin(), __str.end()); }
>
> basic_string(basic_string&& __str, const _Alloc& __a)
> noexcept(_Alloc_traits::_S_always_equal())
> : _M_dataplus(_M_local_data(), __a)
> {
> if (__str._M_is_local())
> {
> traits_type::copy(_M_local_buf, __str._M_local_buf,
> _S_local_capacity + 1);
> _M_length(__str.length());
> __str._M_set_length(0);
> }
> else if (_Alloc_traits::_S_always_equal()
> || __str.get_allocator() == __a)
> {
> _M_data(__str._M_data());
> _M_length(__str.length());
> _M_capacity(__str._M_allocated_capacity);
> __str._M_data(__str._M_local_buf);
> __str._M_set_length(0);
> }
> else
> _M_construct(__str.begin(), __str.end());
> }
># 599 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
>
>
>
> basic_string(_InputIterator __beg, _InputIterator __end,
> const _Alloc& __a = _Alloc())
> : _M_dataplus(_M_local_data(), __a)
> { _M_construct(__beg, __end); }
># 617 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp, typename = _If_sv<_Tp, void>>
> basic_string(const _Tp& __t, size_type __pos, size_type __n,
> const _Alloc& __a = _Alloc())
> : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
>
>
>
>
>
>
> template<typename _Tp, typename = _If_sv<_Tp, void>>
> explicit
> basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
> : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
>
>
>
>
>
>
>
> explicit
> basic_string(__sv_wrapper __svw, const _Alloc& __a)
> : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
>
>
>
>
>
> ~basic_string()
> { _M_dispose(); }
>
>
>
>
>
> basic_string&
> operator=(const basic_string& __str)
> {
>
> if (_Alloc_traits::_S_propagate_on_copy_assign())
> {
> if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
> && _M_get_allocator() != __str._M_get_allocator())
> {
>
>
> if (__str.size() <= _S_local_capacity)
> {
> _M_destroy(_M_allocated_capacity);
> _M_data(_M_local_data());
> _M_set_length(0);
> }
> else
> {
> const auto __len = __str.size();
> auto __alloc = __str._M_get_allocator();
>
> auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
> _M_destroy(_M_allocated_capacity);
> _M_data(__ptr);
> _M_capacity(__len);
> _M_set_length(__len);
> }
> }
> std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
> }
>
> return this->assign(__str);
> }
>
>
>
>
>
> basic_string&
> operator=(const _CharT* __s)
> { return this->assign(__s); }
># 703 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> operator=(_CharT __c)
> {
> this->assign(1, __c);
> return *this;
> }
># 721 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> operator=(basic_string&& __str)
> noexcept(_Alloc_traits::_S_nothrow_move())
> {
> if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
> && !_Alloc_traits::_S_always_equal()
> && _M_get_allocator() != __str._M_get_allocator())
> {
>
> _M_destroy(_M_allocated_capacity);
> _M_data(_M_local_data());
> _M_set_length(0);
> }
>
> std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
>
> if (!__str._M_is_local()
> && (_Alloc_traits::_S_propagate_on_move_assign()
> || _Alloc_traits::_S_always_equal()))
> {
> pointer __data = nullptr;
> size_type __capacity;
> if (!_M_is_local())
> {
> if (_Alloc_traits::_S_always_equal())
> {
> __data = _M_data();
> __capacity = _M_allocated_capacity;
> }
> else
> _M_destroy(_M_allocated_capacity);
> }
>
> _M_data(__str._M_data());
> _M_length(__str.length());
> _M_capacity(__str._M_allocated_capacity);
> if (__data)
> {
> __str._M_data(__data);
> __str._M_capacity(__capacity);
> }
> else
> __str._M_data(__str._M_local_buf);
> }
> else
> assign(__str);
> __str.clear();
> return *this;
> }
>
>
>
>
>
> basic_string&
> operator=(initializer_list<_CharT> __l)
> {
> this->assign(__l.begin(), __l.size());
> return *this;
> }
>
>
>
>
>
>
>
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> operator=(const _Tp& __svt)
> { return this->assign(__svt); }
>
>
>
>
>
> operator __sv_type() const noexcept
> { return __sv_type(data(), size()); }
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return iterator(_M_data()); }
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(_M_data()); }
>
>
>
>
>
> iterator
> end() noexcept
> { return iterator(_M_data() + this->size()); }
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(_M_data() + this->size()); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_data()); }
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(this->_M_data() + this->size()); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
> public:
>
>
>
> size_type
> size() const noexcept
> { return _M_string_length; }
>
>
>
> size_type
> length() const noexcept
> { return _M_string_length; }
>
>
> size_type
> max_size() const noexcept
> { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
># 935 "/usr/include/c++/8/bits/basic_string.h" 3
> void
> resize(size_type __n, _CharT __c);
># 948 "/usr/include/c++/8/bits/basic_string.h" 3
> void
> resize(size_type __n)
> { this->resize(__n, _CharT()); }
>
>
>
> void
> shrink_to_fit() noexcept
> {
>
> if (capacity() > size())
> {
> try
> { reserve(0); }
> catch(...)
> { }
> }
>
> }
>
>
>
>
>
>
> size_type
> capacity() const noexcept
> {
> return _M_is_local() ? size_type(_S_local_capacity)
> : _M_allocated_capacity;
> }
># 997 "/usr/include/c++/8/bits/basic_string.h" 3
> void
> reserve(size_type __res_arg = 0);
>
>
>
>
> void
> clear() noexcept
> { _M_set_length(0); }
>
>
>
>
>
> bool
> empty() const noexcept
> { return this->size() == 0; }
># 1026 "/usr/include/c++/8/bits/basic_string.h" 3
> const_reference
> operator[] (size_type __pos) const noexcept
> {
> ;
> return _M_data()[__pos];
> }
># 1043 "/usr/include/c++/8/bits/basic_string.h" 3
> reference
> operator[](size_type __pos)
> {
>
>
> ;
>
> ;
> return _M_data()[__pos];
> }
># 1064 "/usr/include/c++/8/bits/basic_string.h" 3
> const_reference
> at(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
>
> ,
> __n, this->size());
> return _M_data()[__n];
> }
># 1085 "/usr/include/c++/8/bits/basic_string.h" 3
> reference
> at(size_type __n)
> {
> if (__n >= size())
> __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
>
> ,
> __n, this->size());
> return _M_data()[__n];
> }
>
>
>
>
>
>
> reference
> front() noexcept
> {
> ;
> return operator[](0);
> }
>
>
>
>
>
> const_reference
> front() const noexcept
> {
> ;
> return operator[](0);
> }
>
>
>
>
>
> reference
> back() noexcept
> {
> ;
> return operator[](this->size() - 1);
> }
>
>
>
>
>
> const_reference
> back() const noexcept
> {
> ;
> return operator[](this->size() - 1);
> }
># 1148 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> operator+=(const basic_string& __str)
> { return this->append(__str); }
>
>
>
>
>
>
> basic_string&
> operator+=(const _CharT* __s)
> { return this->append(__s); }
>
>
>
>
>
>
> basic_string&
> operator+=(_CharT __c)
> {
> this->push_back(__c);
> return *this;
> }
>
>
>
>
>
>
>
> basic_string&
> operator+=(initializer_list<_CharT> __l)
> { return this->append(__l.begin(), __l.size()); }
># 1190 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> operator+=(const _Tp& __svt)
> { return this->append(__svt); }
>
>
>
>
>
>
>
> basic_string&
> append(const basic_string& __str)
> { return _M_append(__str._M_data(), __str.size()); }
># 1218 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> append(const basic_string& __str, size_type __pos, size_type __n)
> { return _M_append(__str._M_data()
> + __str._M_check(__pos, "basic_string::append"),
> __str._M_limit(__pos, __n)); }
>
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s, size_type __n)
> {
> ;
> _M_check_length(size_type(0), __n, "basic_string::append");
> return _M_append(__s, __n);
> }
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s)
> {
> ;
> const size_type __n = traits_type::length(__s);
> _M_check_length(size_type(0), __n, "basic_string::append");
> return _M_append(__s, __n);
> }
># 1260 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> append(size_type __n, _CharT __c)
> { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
>
>
>
>
>
>
>
> basic_string&
> append(initializer_list<_CharT> __l)
> { return this->append(__l.begin(), __l.size()); }
># 1284 "/usr/include/c++/8/bits/basic_string.h" 3
> template<class _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
>
>
>
> basic_string&
> append(_InputIterator __first, _InputIterator __last)
> { return this->replace(end(), end(), __first, __last); }
>
>
>
>
>
>
>
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> append(const _Tp& __svt)
> {
> __sv_type __sv = __svt;
> return this->append(__sv.data(), __sv.size());
> }
># 1314 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> append(const _Tp& __svt, size_type __pos, size_type __n = npos)
> {
> __sv_type __sv = __svt;
> return _M_append(__sv.data()
> + __sv._M_check(__pos, "basic_string::append"),
> __sv._M_limit(__pos, __n));
> }
>
>
>
>
>
>
> void
> push_back(_CharT __c)
> {
> const size_type __size = this->size();
> if (__size + 1 > this->capacity())
> this->_M_mutate(__size, size_type(0), 0, size_type(1));
> traits_type::assign(this->_M_data()[__size], __c);
> this->_M_set_length(__size + 1);
> }
>
>
>
>
>
>
> basic_string&
> assign(const basic_string& __str)
> {
> this->_M_assign(__str);
> return *this;
> }
># 1360 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> assign(basic_string&& __str)
> noexcept(_Alloc_traits::_S_nothrow_move())
> {
>
>
> return *this = std::move(__str);
> }
># 1383 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> assign(const basic_string& __str, size_type __pos, size_type __n)
> { return _M_replace(size_type(0), this->size(), __str._M_data()
> + __str._M_check(__pos, "basic_string::assign"),
> __str._M_limit(__pos, __n)); }
># 1399 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s, size_type __n)
> {
> ;
> return _M_replace(size_type(0), this->size(), __s, __n);
> }
># 1415 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s)
> {
> ;
> return _M_replace(size_type(0), this->size(), __s,
> traits_type::length(__s));
> }
># 1432 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> assign(size_type __n, _CharT __c)
> { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
># 1445 "/usr/include/c++/8/bits/basic_string.h" 3
> template<class _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
>
>
>
> basic_string&
> assign(_InputIterator __first, _InputIterator __last)
> { return this->replace(begin(), end(), __first, __last); }
>
>
>
>
>
>
>
> basic_string&
> assign(initializer_list<_CharT> __l)
> { return this->assign(__l.begin(), __l.size()); }
># 1471 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> assign(const _Tp& __svt)
> {
> __sv_type __sv = __svt;
> return this->assign(__sv.data(), __sv.size());
> }
># 1486 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
> {
> __sv_type __sv = __svt;
> return _M_replace(size_type(0), this->size(), __sv.data()
> + __sv._M_check(__pos, "basic_string::assign"),
> __sv._M_limit(__pos, __n));
> }
># 1513 "/usr/include/c++/8/bits/basic_string.h" 3
> iterator
> insert(const_iterator __p, size_type __n, _CharT __c)
> {
> ;
> const size_type __pos = __p - begin();
> this->replace(__p, __p, __n, __c);
> return iterator(this->_M_data() + __pos);
> }
># 1555 "/usr/include/c++/8/bits/basic_string.h" 3
> template<class _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> iterator
> insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
> {
> ;
> const size_type __pos = __p - begin();
> this->replace(__p, __p, __beg, __end);
> return iterator(this->_M_data() + __pos);
> }
># 1591 "/usr/include/c++/8/bits/basic_string.h" 3
> void
> insert(iterator __p, initializer_list<_CharT> __l)
> {
> ;
> this->insert(__p - begin(), __l.begin(), __l.size());
> }
># 1611 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str)
> { return this->replace(__pos1, size_type(0),
> __str._M_data(), __str.size()); }
># 1634 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str,
> size_type __pos2, size_type __n)
> { return this->replace(__pos1, size_type(0), __str._M_data()
> + __str._M_check(__pos2, "basic_string::insert"),
> __str._M_limit(__pos2, __n)); }
># 1657 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s, size_type __n)
> { return this->replace(__pos, size_type(0), __s, __n); }
># 1676 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s)
> {
> ;
> return this->replace(__pos, size_type(0), __s,
> traits_type::length(__s));
> }
># 1700 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, size_type __n, _CharT __c)
> { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
> size_type(0), __n, __c); }
># 1718 "/usr/include/c++/8/bits/basic_string.h" 3
> iterator
> insert(__const_iterator __p, _CharT __c)
> {
> ;
> const size_type __pos = __p - begin();
> _M_replace_aux(__pos, size_type(0), size_type(1), __c);
> return iterator(_M_data() + __pos);
> }
># 1734 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> insert(size_type __pos, const _Tp& __svt)
> {
> __sv_type __sv = __svt;
> return this->insert(__pos, __sv.data(), __sv.size());
> }
># 1751 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> insert(size_type __pos1, const _Tp& __svt,
> size_type __pos2, size_type __n = npos)
> {
> __sv_type __sv = __svt;
> return this->replace(__pos1, size_type(0), __sv.data()
> + __sv._M_check(__pos2, "basic_string::insert"),
> __sv._M_limit(__pos2, __n));
> }
># 1778 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> erase(size_type __pos = 0, size_type __n = npos)
> {
> _M_check(__pos, "basic_string::erase");
> if (__n == npos)
> this->_M_set_length(__pos);
> else if (__n != 0)
> this->_M_erase(__pos, _M_limit(__pos, __n));
> return *this;
> }
># 1797 "/usr/include/c++/8/bits/basic_string.h" 3
> iterator
> erase(__const_iterator __position)
> {
>
> ;
> const size_type __pos = __position - begin();
> this->_M_erase(__pos, size_type(1));
> return iterator(_M_data() + __pos);
> }
># 1816 "/usr/include/c++/8/bits/basic_string.h" 3
> iterator
> erase(__const_iterator __first, __const_iterator __last)
> {
>
> ;
> const size_type __pos = __first - begin();
> if (__last == end())
> this->_M_set_length(__pos);
> else
> this->_M_erase(__pos, __last - __first);
> return iterator(this->_M_data() + __pos);
> }
>
>
>
>
>
>
>
> void
> pop_back() noexcept
> {
> ;
> _M_erase(size() - 1, 1);
> }
># 1860 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n, const basic_string& __str)
> { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
># 1882 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2)
> { return this->replace(__pos1, __n1, __str._M_data()
> + __str._M_check(__pos2, "basic_string::replace"),
> __str._M_limit(__pos2, __n2)); }
># 1907 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> ;
> return _M_replace(_M_check(__pos, "basic_string::replace"),
> _M_limit(__pos, __n1), __s, __n2);
> }
># 1932 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s)
> {
> ;
> return this->replace(__pos, __n1, __s, traits_type::length(__s));
> }
># 1956 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
> { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
> _M_limit(__pos, __n1), __n2, __c); }
># 1974 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2,
> const basic_string& __str)
> { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
># 1994 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2,
> const _CharT* __s, size_type __n)
> {
>
> ;
> return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
> }
># 2016 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
> {
> ;
> return this->replace(__i1, __i2, __s, traits_type::length(__s));
> }
># 2037 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
> _CharT __c)
> {
>
> ;
> return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
> }
># 2062 "/usr/include/c++/8/bits/basic_string.h" 3
> template<class _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> basic_string&
> replace(const_iterator __i1, const_iterator __i2,
> _InputIterator __k1, _InputIterator __k2)
> {
> 
> ;
> ;
> return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
> std::__false_type());
> }
># 2094 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2,
> _CharT* __k1, _CharT* __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - begin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2,
> const _CharT* __k1, const _CharT* __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - begin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2,
> iterator __k1, iterator __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - begin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
>
> basic_string&
> replace(__const_iterator __i1, __const_iterator __i2,
> const_iterator __k1, const_iterator __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - begin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
># 2153 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string& replace(const_iterator __i1, const_iterator __i2,
> initializer_list<_CharT> __l)
> { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
># 2166 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> replace(size_type __pos, size_type __n, const _Tp& __svt)
> {
> __sv_type __sv = __svt;
> return this->replace(__pos, __n, __sv.data(), __sv.size());
> }
># 2183 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> replace(size_type __pos1, size_type __n1, const _Tp& __svt,
> size_type __pos2, size_type __n2 = npos)
> {
> __sv_type __sv = __svt;
> return this->replace(__pos1, __n1, __sv.data()
> + __sv._M_check(__pos2, "basic_string::replace"),
> __sv._M_limit(__pos2, __n2));
> }
># 2203 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, basic_string&>
> replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
> {
> __sv_type __sv = __svt;
> return this->replace(__i1 - begin(), __i2 - __i1, __sv);
> }
>
>
> private:
> template<class _Integer>
> basic_string&
> _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
> _Integer __n, _Integer __val, __true_type)
> { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
>
> template<class _InputIterator>
> basic_string&
> _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
> _InputIterator __k1, _InputIterator __k2,
> __false_type);
>
> basic_string&
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c);
>
> basic_string&
> _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
> const size_type __len2);
>
> basic_string&
> _M_append(const _CharT* __s, size_type __n);
>
> public:
># 2250 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
># 2260 "/usr/include/c++/8/bits/basic_string.h" 3
> void
> swap(basic_string& __s) noexcept;
># 2270 "/usr/include/c++/8/bits/basic_string.h" 3
> const _CharT*
> c_str() const noexcept
> { return _M_data(); }
># 2282 "/usr/include/c++/8/bits/basic_string.h" 3
> const _CharT*
> data() const noexcept
> { return _M_data(); }
># 2293 "/usr/include/c++/8/bits/basic_string.h" 3
> _CharT*
> data() noexcept
> { return _M_data(); }
>
>
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return _M_get_allocator(); }
># 2317 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept;
># 2331 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find(__str.data(), __pos, __str.size()); }
># 2343 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, size_type>
> find(const _Tp& __svt, size_type __pos = 0) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return this->find(__sv.data(), __pos, __sv.size());
> }
># 2363 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos = 0) const noexcept
> {
> ;
> return this->find(__s, __pos, traits_type::length(__s));
> }
># 2380 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find(_CharT __c, size_type __pos = 0) const noexcept;
># 2393 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> rfind(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->rfind(__str.data(), __pos, __str.size()); }
># 2405 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, size_type>
> rfind(const _Tp& __svt, size_type __pos = npos) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return this->rfind(__sv.data(), __pos, __sv.size());
> }
># 2427 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept;
># 2441 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos = npos) const
> {
> ;
> return this->rfind(__s, __pos, traits_type::length(__s));
> }
># 2458 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> rfind(_CharT __c, size_type __pos = npos) const noexcept;
># 2472 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_of(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find_first_of(__str.data(), __pos, __str.size()); }
># 2485 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, size_type>
> find_first_of(const _Tp& __svt, size_type __pos = 0) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return this->find_first_of(__sv.data(), __pos, __sv.size());
> }
># 2507 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept;
># 2521 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos = 0) const
> noexcept
> {
> ;
> return this->find_first_of(__s, __pos, traits_type::length(__s));
> }
># 2541 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_of(_CharT __c, size_type __pos = 0) const noexcept
> { return this->find(__c, __pos); }
># 2556 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_of(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->find_last_of(__str.data(), __pos, __str.size()); }
># 2569 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, size_type>
> find_last_of(const _Tp& __svt, size_type __pos = npos) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return this->find_last_of(__sv.data(), __pos, __sv.size());
> }
># 2591 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept;
># 2605 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos = npos) const
> noexcept
> {
> ;
> return this->find_last_of(__s, __pos, traits_type::length(__s));
> }
># 2625 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_of(_CharT __c, size_type __pos = npos) const noexcept
> { return this->rfind(__c, __pos); }
># 2639 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_not_of(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
># 2652 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, size_type>
> find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return this->find_first_not_of(__sv.data(), __pos, __sv.size());
> }
># 2674 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const noexcept;
># 2688 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos = 0) const
> noexcept
> {
> ;
> return this->find_first_not_of(__s, __pos, traits_type::length(__s));
> }
># 2706 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const
> noexcept;
># 2721 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_not_of(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
># 2734 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, size_type>
> find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return this->find_last_not_of(__sv.data(), __pos, __sv.size());
> }
># 2756 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const noexcept;
># 2770 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos = npos) const
> noexcept
> {
> ;
> return this->find_last_not_of(__s, __pos, traits_type::length(__s));
> }
># 2788 "/usr/include/c++/8/bits/basic_string.h" 3
> size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const
> noexcept;
># 2804 "/usr/include/c++/8/bits/basic_string.h" 3
> basic_string
> substr(size_type __pos = 0, size_type __n = npos) const
> { return basic_string(*this,
> _M_check(__pos, "basic_string::substr"), __n); }
># 2823 "/usr/include/c++/8/bits/basic_string.h" 3
> int
> compare(const basic_string& __str) const
> {
> const size_type __size = this->size();
> const size_type __osize = __str.size();
> const size_type __len = std::min(__size, __osize);
>
> int __r = traits_type::compare(_M_data(), __str.data(), __len);
> if (!__r)
> __r = _S_compare(__size, __osize);
> return __r;
> }
>
>
>
>
>
>
>
> template<typename _Tp>
> _If_sv<_Tp, int>
> compare(const _Tp& __svt) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> const size_type __size = this->size();
> const size_type __osize = __sv.size();
> const size_type __len = std::min(__size, __osize);
>
> int __r = traits_type::compare(_M_data(), __sv.data(), __len);
> if (!__r)
> __r = _S_compare(__size, __osize);
> return __r;
> }
># 2866 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, int>
> compare(size_type __pos, size_type __n, const _Tp& __svt) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return __sv_type(*this).substr(__pos, __n).compare(__sv);
> }
># 2885 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _Tp>
> _If_sv<_Tp, int>
> compare(size_type __pos1, size_type __n1, const _Tp& __svt,
> size_type __pos2, size_type __n2 = npos) const
> noexcept(is_same<_Tp, __sv_type>::value)
> {
> __sv_type __sv = __svt;
> return __sv_type(*this)
> .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
> }
># 2916 "/usr/include/c++/8/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n, const basic_string& __str) const;
># 2942 "/usr/include/c++/8/bits/basic_string.h" 3
> int
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const;
># 2960 "/usr/include/c++/8/bits/basic_string.h" 3
> int
> compare(const _CharT* __s) const noexcept;
># 2984 "/usr/include/c++/8/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s) const;
># 3011 "/usr/include/c++/8/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const;
>
>
> template<typename, typename, typename> friend class basic_stringbuf;
> };
>}
># 5868 "/usr/include/c++/8/bits/basic_string.h" 3
>namespace __cxx11 {
> template<typename _InputIterator, typename _CharT
> = typename iterator_traits<_InputIterator>::value_type,
> typename _Allocator = allocator<_CharT>,
> typename = _RequireInputIter<_InputIterator>,
> typename = _RequireAllocator<_Allocator>>
> basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
> -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
>}
># 5886 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str(__lhs);
> __str.append(__size_type(1), __rhs);
> return __str;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return std::move(__lhs.append(__rhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> {
> const auto __size = __lhs.size() + __rhs.size();
> const bool __cond = (__size > __lhs.capacity()
> && __size <= __rhs.capacity());
> return __cond ? std::move(__rhs.insert(0, __lhs))
> : std::move(__lhs.append(__rhs));
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, 1, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> const _CharT* __rhs)
> { return std::move(__lhs.append(__rhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> _CharT __rhs)
> { return std::move(__lhs.append(1, __rhs)); }
># 6007 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept
> { return __lhs.compare(__rhs) == 0; }
>
> template<typename _CharT>
> inline
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
> operator==(const basic_string<_CharT>& __lhs,
> const basic_string<_CharT>& __rhs) noexcept
> { return (__lhs.size() == __rhs.size()
> && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
> __lhs.size())); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) == 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) == 0; }
># 6054 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return !(__lhs == __rhs); }
># 6092 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) > 0; }
># 6130 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) < 0; }
># 6168 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) >= 0; }
># 6206 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) <= 0; }
># 6244 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline void
> swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>& __rhs)
> noexcept(noexcept(__lhs.swap(__rhs)))
> { __lhs.swap(__rhs); }
># 6264 "/usr/include/c++/8/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);
># 6282 "/usr/include/c++/8/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());
> }
># 6305 "/usr/include/c++/8/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);
># 6322 "/usr/include/c++/8/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> { return std::getline(__is, __str, __is.widen('\n')); }
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>&& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
> { return std::getline(__is, __str, __delim); }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>&& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> { return std::getline(__is, __str); }
>
>
> template<>
> basic_istream<char>&
> getline(basic_istream<char>& __in, basic_string<char>& __str,
> char __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
> wchar_t __delim);
>
>
>
>}
>
>
>
># 1 "/usr/include/c++/8/ext/string_conversions.h" 1 3
># 32 "/usr/include/c++/8/ext/string_conversions.h" 3
> 
># 33 "/usr/include/c++/8/ext/string_conversions.h" 3
># 41 "/usr/include/c++/8/ext/string_conversions.h" 3
># 1 "/usr/include/c++/8/cstdlib" 1 3
># 39 "/usr/include/c++/8/cstdlib" 3
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 75 "/usr/include/c++/8/cstdlib" 3
># 1 "/usr/include/stdlib.h" 1 3 4
># 25 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/bits/libc-header-start.h" 1 3 4
># 26 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 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) throw () ;
>
>
>
>extern double atof (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern int atoi (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>extern long int atol (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>__extension__ extern long long int atoll (const char *__nptr)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern double strtod (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern float strtof (const char *__restrict __nptr,
> char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
>
>extern long double strtold (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
># 140 "/usr/include/stdlib.h" 3 4
>extern _Float32 strtof32 (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern _Float64 strtof64 (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern _Float128 strtof128 (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern _Float32x strtof32x (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern _Float64x strtof64x (const char *__restrict __nptr,
> char **__restrict __endptr)
> throw () __attribute__ ((__nonnull__ (1)));
># 176 "/usr/include/stdlib.h" 3 4
>extern long int strtol (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>extern unsigned long int strtoul (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>__extension__
>extern long long int strtoq (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtouq (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>__extension__
>extern long long int strtoll (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>__extension__
>extern unsigned long long int strtoull (const char *__restrict __nptr,
> char **__restrict __endptr, int __base)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int strfromd (char *__dest, size_t __size, const char *__format,
> double __f)
> throw () __attribute__ ((__nonnull__ (3)));
>
>extern int strfromf (char *__dest, size_t __size, const char *__format,
> float __f)
> throw () __attribute__ ((__nonnull__ (3)));
>
>extern int strfroml (char *__dest, size_t __size, const char *__format,
> long double __f)
> throw () __attribute__ ((__nonnull__ (3)));
># 232 "/usr/include/stdlib.h" 3 4
>extern int strfromf32 (char *__dest, size_t __size, const char * __format,
> _Float32 __f)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>
>extern int strfromf64 (char *__dest, size_t __size, const char * __format,
> _Float64 __f)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>
>extern int strfromf128 (char *__dest, size_t __size, const char * __format,
> _Float128 __f)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>
>extern int strfromf32x (char *__dest, size_t __size, const char * __format,
> _Float32x __f)
> throw () __attribute__ ((__nonnull__ (3)));
>
>
>
>extern int strfromf64x (char *__dest, size_t __size, const char * __format,
> _Float64x __f)
> throw () __attribute__ ((__nonnull__ (3)));
># 274 "/usr/include/stdlib.h" 3 4
>extern long int strtol_l (const char *__restrict __nptr,
> char **__restrict __endptr, int __base,
> locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
>
>extern unsigned long int strtoul_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern long long int strtoll_l (const char *__restrict __nptr,
> char **__restrict __endptr, int __base,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4)));
>
>__extension__
>extern unsigned long long int strtoull_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 4)));
>
>extern double strtod_l (const char *__restrict __nptr,
> char **__restrict __endptr, locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>extern float strtof_l (const char *__restrict __nptr,
> char **__restrict __endptr, locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>extern long double strtold_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
># 316 "/usr/include/stdlib.h" 3 4
>extern _Float32 strtof32_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern _Float64 strtof64_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern _Float128 strtof128_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern _Float32x strtof32x_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern _Float64x strtof64x_l (const char *__restrict __nptr,
> char **__restrict __endptr,
> locale_t __loc)
> throw () __attribute__ ((__nonnull__ (1, 3)));
># 360 "/usr/include/stdlib.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) atoi (const char *__nptr) throw ()
>{
> return (int) strtol (__nptr, (char **) __null, 10);
>}
>extern __inline __attribute__ ((__gnu_inline__)) long int
>__attribute__ ((__leaf__)) atol (const char *__nptr) throw ()
>{
> return strtol (__nptr, (char **) __null, 10);
>}
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
>__attribute__ ((__leaf__)) atoll (const char *__nptr) throw ()
>{
> return strtoll (__nptr, (char **) __null, 10);
>}
># 385 "/usr/include/stdlib.h" 3 4
>extern char *l64a (long int __n) throw () ;
>
>
>extern long int a64l (const char *__s)
> throw () __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;
># 104 "/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;
># 135 "/usr/include/sys/types.h" 3 4
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 146 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 178 "/usr/include/sys/types.h" 3 4
>typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
>typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
>
>typedef int register_t __attribute__ ((__mode__ (__word__)));
># 197 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 30 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 22 "/usr/include/bits/select.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/select.h" 2 3 4
># 31 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/types/sigset_t.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4
>
>
>
>
>typedef struct
>{
> unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>} __sigset_t;
># 5 "/usr/include/bits/types/sigset_t.h" 2 3 4
>
>
>typedef __sigset_t sigset_t;
># 34 "/usr/include/sys/select.h" 2 3 4
># 49 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 59 "/usr/include/sys/select.h" 3 4
>typedef struct
> {
>
>
>
> __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
>
>
>
>
>
> } fd_set;
>
>
>
>
>
>
>typedef __fd_mask fd_mask;
># 91 "/usr/include/sys/select.h" 3 4
>extern "C" {
># 101 "/usr/include/sys/select.h" 3 4
>extern int select (int __nfds, fd_set *__restrict __readfds,
> fd_set *__restrict __writefds,
> fd_set *__restrict __exceptfds,
> struct timeval *__restrict __timeout);
># 113 "/usr/include/sys/select.h" 3 4
>extern int pselect (int __nfds, fd_set *__restrict __readfds,
> fd_set *__restrict __writefds,
> fd_set *__restrict __exceptfds,
> const struct timespec *__restrict __timeout,
> const __sigset_t *__restrict __sigmask);
># 126 "/usr/include/sys/select.h" 3 4
>}
># 198 "/usr/include/sys/types.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 41 "/usr/include/sys/sysmacros.h" 3 4
># 1 "/usr/include/bits/sysmacros.h" 1 3 4
># 42 "/usr/include/sys/sysmacros.h" 2 3 4
># 71 "/usr/include/sys/sysmacros.h" 3 4
>extern "C" {
>
>extern unsigned int gnu_dev_major (__dev_t __dev) throw () __attribute__ ((__const__));
>extern unsigned int gnu_dev_minor (__dev_t __dev) throw () __attribute__ ((__const__));
>extern __dev_t gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw () __attribute__ ((__const__));
>
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int __attribute__ ((__leaf__)) gnu_dev_major (__dev_t __dev) throw () { unsigned int __major; __major = ((__dev & (__dev_t) 0x00000000000fff00u) >> 8); __major |= ((__dev & (__dev_t) 0xfffff00000000000u) >> 32); return __major; }
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int __attribute__ ((__leaf__)) gnu_dev_minor (__dev_t __dev) throw () { unsigned int __minor; __minor = ((__dev & (__dev_t) 0x00000000000000ffu) >> 0); __minor |= ((__dev & (__dev_t) 0x00000ffffff00000u) >> 12); return __minor; }
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) __dev_t __attribute__ ((__leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw () { __dev_t __dev; __dev = (((__dev_t) (__major & 0x00000fffu)) << 8); __dev |= (((__dev_t) (__major & 0xfffff000u)) << 32); __dev |= (((__dev_t) (__minor & 0x000000ffu)) << 0); __dev |= (((__dev_t) (__minor & 0xffffff00u)) << 12); return __dev; }
>
>
>
>}
># 206 "/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;
># 246 "/usr/include/sys/types.h" 3 4
>typedef __blkcnt64_t blkcnt64_t;
>typedef __fsblkcnt64_t fsblkcnt64_t;
>typedef __fsfilcnt64_t fsfilcnt64_t;
># 257 "/usr/include/sys/types.h" 3 4
>}
># 395 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>
>extern long int random (void) throw ();
>
>
>extern void srandom (unsigned int __seed) throw ();
>
>
>
>
>
>extern char *initstate (unsigned int __seed, char *__statebuf,
> size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>struct random_data
> {
> int32_t *fptr;
> int32_t *rptr;
> int32_t *state;
> int rand_type;
> int rand_deg;
> int rand_sep;
> int32_t *end_ptr;
> };
>
>extern int random_r (struct random_data *__restrict __buf,
> int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int srandom_r (unsigned int __seed, struct random_data *__buf)
> throw () __attribute__ ((__nonnull__ (2)));
>
>extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
> size_t __statelen,
> struct random_data *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (2, 4)));
>
>extern int setstate_r (char *__restrict __statebuf,
> struct random_data *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int rand (void) throw ();
>
>extern void srand (unsigned int __seed) throw ();
>
>
>
>extern int rand_r (unsigned int *__seed) throw ();
>
>
>
>
>
>
>
>extern double drand48 (void) throw ();
>extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int lrand48 (void) throw ();
>extern long int nrand48 (unsigned short int __xsubi[3])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int mrand48 (void) throw ();
>extern long int jrand48 (unsigned short int __xsubi[3])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void srand48 (long int __seedval) throw ();
>extern unsigned short int *seed48 (unsigned short int __seed16v[3])
> throw () __attribute__ ((__nonnull__ (1)));
>extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>struct drand48_data
> {
> unsigned short int __x[3];
> unsigned short int __old_x[3];
> unsigned short int __c;
> unsigned short int __init;
> __extension__ unsigned long long int __a;
>
> };
>
>
>extern int drand48_r (struct drand48_data *__restrict __buffer,
> double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int erand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int lrand48_r (struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int nrand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int mrand48_r (struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int jrand48_r (unsigned short int __xsubi[3],
> struct drand48_data *__restrict __buffer,
> long int *__restrict __result)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
> throw () __attribute__ ((__nonnull__ (2)));
>
>extern int seed48_r (unsigned short int __seed16v[3],
> struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern int lcong48_r (unsigned short int __param[7],
> struct drand48_data *__buffer)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
>
>extern void *calloc (size_t __nmemb, size_t __size)
> throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>extern void *realloc (void *__ptr, size_t __size)
> throw () __attribute__ ((__warn_unused_result__));
>
>
>
>
>
>
>
>extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
> throw () __attribute__ ((__warn_unused_result__));
>
>
>
>extern void free (void *__ptr) throw ();
>
>
># 1 "/usr/include/alloca.h" 1 3 4
># 24 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 25 "/usr/include/alloca.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>extern void *alloca (size_t __size) throw ();
>
>
>
>
>
>}
># 567 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>
>extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern void *aligned_alloc (size_t __alignment, size_t __size)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
>
>
>
>extern void abort (void) throw () __attribute__ ((__noreturn__));
>
>
>
>extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern "C++" int at_quick_exit (void (*__func) (void))
> throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
># 607 "/usr/include/stdlib.h" 3 4
>extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern void exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>
>extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>extern char *secure_getenv (const char *__name)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int setenv (const char *__name, const char *__value, int __replace)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int clearenv (void) throw ();
># 672 "/usr/include/stdlib.h" 3 4
>extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
># 685 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 695 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 707 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
># 717 "/usr/include/stdlib.h" 3 4
>extern int mkstemps64 (char *__template, int __suffixlen)
> __attribute__ ((__nonnull__ (1))) ;
># 728 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
># 739 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 749 "/usr/include/stdlib.h" 3 4
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 759 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags)
> __attribute__ ((__nonnull__ (1))) ;
># 771 "/usr/include/stdlib.h" 3 4
>extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
> __attribute__ ((__nonnull__ (1))) ;
># 781 "/usr/include/stdlib.h" 3 4
>extern int system (const char *__command) ;
>
>
>
>
>
>extern char *canonicalize_file_name (const char *__name)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 797 "/usr/include/stdlib.h" 3 4
>extern char *realpath (const char *__restrict __name,
> char *__restrict __resolved) throw () ;
>
>
>
>
>
>
>typedef int (*__compar_fn_t) (const void *, const void *);
>
>
>typedef __compar_fn_t comparison_fn_t;
>
>
>
>typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
>
>
>
>
>extern void *bsearch (const void *__key, const void *__base,
> size_t __nmemb, size_t __size, __compar_fn_t __compar)
> __attribute__ ((__nonnull__ (1, 2, 5))) ;
>
>
># 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4
># 19 "/usr/include/bits/stdlib-bsearch.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) void *
>bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
> __compar_fn_t __compar)
>{
> size_t __l, __u, __idx;
> const void *__p;
> int __comparison;
>
> __l = 0;
> __u = __nmemb;
> while (__l < __u)
> {
> __idx = (__l + __u) / 2;
> __p = (void *) (((const char *) __base) + (__idx * __size));
> __comparison = (*__compar) (__key, __p);
> if (__comparison < 0)
> __u = __idx;
> else if (__comparison > 0)
> __l = __idx + 1;
> else
> return (void *) __p;
> }
>
> return __null;
>}
># 823 "/usr/include/stdlib.h" 2 3 4
>
>
>
>
>extern void qsort (void *__base, size_t __nmemb, size_t __size,
> __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
>
>extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
> __compar_d_fn_t __compar, void *__arg)
> __attribute__ ((__nonnull__ (1, 4)));
>
>
>
>
>extern int abs (int __x) throw () __attribute__ ((__const__)) ;
>extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
>
>
>__extension__ extern long long int llabs (long long int __x)
> throw () __attribute__ ((__const__)) ;
>
>
>
>
>
>
>extern div_t div (int __numer, int __denom)
> throw () __attribute__ ((__const__)) ;
>extern ldiv_t ldiv (long int __numer, long int __denom)
> throw () __attribute__ ((__const__)) ;
>
>
>__extension__ extern lldiv_t lldiv (long long int __numer,
> long long int __denom)
> throw () __attribute__ ((__const__)) ;
># 869 "/usr/include/stdlib.h" 3 4
>extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
>
>
>
>
>extern char *gcvt (double __value, int __ndigit, char *__buf)
> throw () __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern char *qecvt (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign)
> throw () __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qfcvt (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign)
> throw () __attribute__ ((__nonnull__ (3, 4))) ;
>extern char *qgcvt (long double __value, int __ndigit, char *__buf)
> throw () __attribute__ ((__nonnull__ (3))) ;
>
>
>
>
>extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
> int *__restrict __sign, char *__restrict __buf,
> size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>extern int qecvt_r (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>extern int qfcvt_r (long double __value, int __ndigit,
> int *__restrict __decpt, int *__restrict __sign,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (3, 4, 5)));
>
>
>
>
>
>extern int mblen (const char *__s, size_t __n) throw ();
>
>
>extern int mbtowc (wchar_t *__restrict __pwc,
> const char *__restrict __s, size_t __n) throw ();
>
>
>extern int wctomb (char *__s, wchar_t __wchar) throw ();
>
>
>
>extern size_t mbstowcs (wchar_t *__restrict __pwcs,
> const char *__restrict __s, size_t __n) throw ();
>
>extern size_t wcstombs (char *__restrict __s,
> const wchar_t *__restrict __pwcs, size_t __n)
> throw ();
>
>
>
>
>
>
>
>extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
># 954 "/usr/include/stdlib.h" 3 4
>extern int getsubopt (char **__restrict __optionp,
> char *const *__restrict __tokens,
> char **__restrict __valuep)
> throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
>
>
>
>
>
>
>
>extern int posix_openpt (int __oflag) ;
>
>
>
>
>
>
>
>extern int grantpt (int __fd) throw ();
>
>
>
>extern int unlockpt (int __fd) throw ();
>
>
>
>
>extern char *ptsname (int __fd) throw () ;
>
>
>
>
>
>
>extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>extern int getpt (void);
>
>
>
>
>
>
>extern int getloadavg (double __loadavg[], int __nelem)
> throw () __attribute__ ((__nonnull__ (1)));
># 1010 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/bits/stdlib-float.h" 1 3 4
># 24 "/usr/include/bits/stdlib-float.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) double
>__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
>{
> return strtod (__nptr, (char **) __null);
>}
># 1011 "/usr/include/stdlib.h" 2 3 4
># 1020 "/usr/include/stdlib.h" 3 4
>}
># 76 "/usr/include/c++/8/cstdlib" 2 3
>
># 1 "/usr/include/c++/8/bits/std_abs.h" 1 3
># 33 "/usr/include/c++/8/bits/std_abs.h" 3
> 
># 34 "/usr/include/c++/8/bits/std_abs.h" 3
># 46 "/usr/include/c++/8/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); }
>
>
>
>
>
>
>
> 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); }
># 106 "/usr/include/c++/8/bits/std_abs.h" 3
>
>}
>}
># 78 "/usr/include/c++/8/cstdlib" 2 3
># 121 "/usr/include/c++/8/cstdlib" 3
>extern "C++"
>{
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::div_t;
> using ::ldiv_t;
>
> using ::abort;
>
> using ::aligned_alloc;
>
> using ::atexit;
>
>
> using ::at_quick_exit;
>
>
> using ::atof;
> using ::atoi;
> using ::atol;
> using ::bsearch;
> using ::calloc;
> using ::div;
> using ::exit;
> using ::free;
> using ::getenv;
> using ::labs;
> using ::ldiv;
> using ::malloc;
>
> using ::mblen;
> using ::mbstowcs;
> using ::mbtowc;
>
> using ::qsort;
>
>
> using ::quick_exit;
>
>
> using ::rand;
> using ::realloc;
> using ::srand;
> using ::strtod;
> using ::strtol;
> using ::strtoul;
> using ::system;
>
> using ::wcstombs;
> using ::wctomb;
>
>
>
> inline ldiv_t
> div(long __i, long __j) { return ldiv(__i, __j); }
>
>
>
>
>}
># 195 "/usr/include/c++/8/cstdlib" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> using ::lldiv_t;
>
>
>
>
>
> using ::_Exit;
>
>
>
> using ::llabs;
>
> inline lldiv_t
> div(long long __n, long long __d)
> { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
>
> using ::lldiv;
># 227 "/usr/include/c++/8/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;
>}
>
>
>
>}
># 42 "/usr/include/c++/8/ext/string_conversions.h" 2 3
># 1 "/usr/include/c++/8/cwchar" 1 3
># 39 "/usr/include/c++/8/cwchar" 3
> 
># 40 "/usr/include/c++/8/cwchar" 3
># 43 "/usr/include/c++/8/ext/string_conversions.h" 2 3
># 1 "/usr/include/c++/8/cstdio" 1 3
># 39 "/usr/include/c++/8/cstdio" 3
> 
># 40 "/usr/include/c++/8/cstdio" 3
>
>
># 1 "/usr/include/stdio.h" 1 3 4
># 27 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/libc-header-start.h" 1 3 4
># 28 "/usr/include/stdio.h" 2 3 4
>
>extern "C" {
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 34 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/bits/libio.h" 1 3 4
># 35 "/usr/include/bits/libio.h" 3 4
># 1 "/usr/include/bits/_G_config.h" 1 3 4
># 19 "/usr/include/bits/_G_config.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 20 "/usr/include/bits/_G_config.h" 2 3 4
>
>
>
>
>
>
>typedef struct
>{
> __off_t __pos;
> __mbstate_t __state;
>} _G_fpos_t;
>typedef struct
>{
> __off64_t __pos;
> __mbstate_t __state;
>} _G_fpos64_t;
># 36 "/usr/include/bits/libio.h" 2 3 4
># 53 "/usr/include/bits/libio.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h" 1 3 4
># 54 "/usr/include/bits/libio.h" 2 3 4
># 149 "/usr/include/bits/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
>
>
>
>
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
> struct _IO_marker *_next;
> struct _IO_FILE *_sbuf;
>
>
>
> int _pos;
># 177 "/usr/include/bits/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
> __codecvt_ok,
> __codecvt_partial,
> __codecvt_error,
> __codecvt_noconv
>};
># 245 "/usr/include/bits/libio.h" 3 4
>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;
># 293 "/usr/include/bits/libio.h" 3 4
> __off64_t _offset;
>
>
>
>
>
>
>
> void *__pad1;
> void *__pad2;
> void *__pad3;
> void *__pad4;
>
> size_t __pad5;
> int _mode;
>
> char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
>
>};
>
>
>
>
>
>struct _IO_FILE_plus;
>
>extern struct _IO_FILE_plus _IO_2_1_stdin_;
>extern struct _IO_FILE_plus _IO_2_1_stdout_;
>extern struct _IO_FILE_plus _IO_2_1_stderr_;
># 337 "/usr/include/bits/libio.h" 3 4
>typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
>
>
>
>
>
>
>
>typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
> size_t __n);
>
>
>
>
>
>
>
>typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
>
>
>typedef int __io_close_fn (void *__cookie);
>
>
>
>
>typedef __io_read_fn cookie_read_function_t;
>typedef __io_write_fn cookie_write_function_t;
>typedef __io_seek_fn cookie_seek_function_t;
>typedef __io_close_fn cookie_close_function_t;
>
>
>typedef struct
>{
> __io_read_fn *read;
> __io_write_fn *write;
> __io_seek_fn *seek;
> __io_close_fn *close;
>} _IO_cookie_io_functions_t;
>typedef _IO_cookie_io_functions_t cookie_io_functions_t;
>
>struct _IO_cookie_file;
>
>
>extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
> void *__cookie, _IO_cookie_io_functions_t __fns);
>
>
>
>
>extern "C" {
>
>
>extern int __underflow (_IO_FILE *);
>extern int __uflow (_IO_FILE *);
>extern int __overflow (_IO_FILE *, int);
># 433 "/usr/include/bits/libio.h" 3 4
>extern int _IO_getc (_IO_FILE *__fp);
>extern int _IO_putc (int __c, _IO_FILE *__fp);
>extern int _IO_feof (_IO_FILE *__fp) throw ();
>extern int _IO_ferror (_IO_FILE *__fp) throw ();
>
>extern int _IO_peekc_locked (_IO_FILE *__fp);
>
>
>
>
>
>extern void _IO_flockfile (_IO_FILE *) throw ();
>extern void _IO_funlockfile (_IO_FILE *) throw ();
>extern int _IO_ftrylockfile (_IO_FILE *) throw ();
># 462 "/usr/include/bits/libio.h" 3 4
>extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
> __gnuc_va_list, int *__restrict);
>extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
> __gnuc_va_list);
>extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
>extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
>
>extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
>extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
>
>extern void _IO_free_backup_area (_IO_FILE *) throw ();
># 524 "/usr/include/bits/libio.h" 3 4
>}
># 42 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 78 "/usr/include/stdio.h" 3 4
>typedef _G_fpos_t fpos_t;
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 131 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 132 "/usr/include/stdio.h" 2 3 4
>
>
>
>extern struct _IO_FILE *stdin;
>extern struct _IO_FILE *stdout;
>extern struct _IO_FILE *stderr;
>
>
>
>
>
>
>extern int remove (const char *__filename) throw ();
>
>extern int rename (const char *__old, const char *__new) throw ();
>
>
>
>extern int renameat (int __oldfd, const char *__old, int __newfd,
> const char *__new) throw ();
>
>
>
>
>
>
>
>extern FILE *tmpfile (void) ;
># 169 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void) ;
>
>
>
>extern char *tmpnam (char *__s) throw () ;
>
>
>
>
>extern char *tmpnam_r (char *__s) throw () ;
># 190 "/usr/include/stdio.h" 3 4
>extern char *tempnam (const char *__dir, const char *__pfx)
> throw () __attribute__ ((__malloc__)) ;
>
>
>
>
>
>
>
>extern int fclose (FILE *__stream);
>
>
>
>
>extern int fflush (FILE *__stream);
># 213 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 223 "/usr/include/stdio.h" 3 4
>extern int fcloseall (void);
># 232 "/usr/include/stdio.h" 3 4
>extern FILE *fopen (const char *__restrict __filename,
> const char *__restrict __modes) ;
>
>
>
>
>extern FILE *freopen (const char *__restrict __filename,
> const char *__restrict __modes,
> FILE *__restrict __stream) ;
># 256 "/usr/include/stdio.h" 3 4
>extern FILE *fopen64 (const char *__restrict __filename,
> const char *__restrict __modes) ;
>extern FILE *freopen64 (const char *__restrict __filename,
> const char *__restrict __modes,
> FILE *__restrict __stream) ;
>
>
>
>
>extern FILE *fdopen (int __fd, const char *__modes) throw () ;
>
>
>
>
>
>extern FILE *fopencookie (void *__restrict __magic_cookie,
> const char *__restrict __modes,
> _IO_cookie_io_functions_t __io_funcs) throw () ;
>
>
>
>
>extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
> throw () ;
>
>
>
>
>extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
>
>
>
>
>
>extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
>
>
>
>extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
> int __modes, size_t __n) throw ();
>
>
>
>
>extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
> size_t __size) throw ();
>
>
>extern void setlinebuf (FILE *__stream) throw ();
>
>
>
>
>
>
>
>extern int fprintf (FILE *__restrict __stream,
> const char *__restrict __format, ...);
>
>
>
>
>extern int printf (const char *__restrict __format, ...);
>
>extern int sprintf (char *__restrict __s,
> const char *__restrict __format, ...) throw ();
>
>
>
>
>
>extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
> __gnuc_va_list __arg);
>
>
>
>
>extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
>
>extern int vsprintf (char *__restrict __s, const char *__restrict __format,
> __gnuc_va_list __arg) throw ();
>
>
>
>extern int snprintf (char *__restrict __s, size_t __maxlen,
> const char *__restrict __format, ...)
> throw () __attribute__ ((__format__ (__printf__, 3, 4)));
>
>extern int vsnprintf (char *__restrict __s, size_t __maxlen,
> const char *__restrict __format, __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__printf__, 3, 0)));
>
>
>
>
>
>extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
> __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
>extern int __asprintf (char **__restrict __ptr,
> const char *__restrict __fmt, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
>extern int asprintf (char **__restrict __ptr,
> const char *__restrict __fmt, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
>
>
>
>
>extern int vdprintf (int __fd, const char *__restrict __fmt,
> __gnuc_va_list __arg)
> __attribute__ ((__format__ (__printf__, 2, 0)));
>extern int dprintf (int __fd, const char *__restrict __fmt, ...)
> __attribute__ ((__format__ (__printf__, 2, 3)));
>
>
>
>
>
>
>
>extern int fscanf (FILE *__restrict __stream,
> const char *__restrict __format, ...) ;
>
>
>
>
>extern int scanf (const char *__restrict __format, ...) ;
>
>extern int sscanf (const char *__restrict __s,
> const char *__restrict __format, ...) throw ();
># 420 "/usr/include/stdio.h" 3 4
>extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
> __gnuc_va_list __arg)
> __attribute__ ((__format__ (__scanf__, 2, 0))) ;
>
>
>
>
>
>extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
> __attribute__ ((__format__ (__scanf__, 1, 0))) ;
>
>
>extern int vsscanf (const char *__restrict __s,
> const char *__restrict __format, __gnuc_va_list __arg)
> throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
># 477 "/usr/include/stdio.h" 3 4
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
># 495 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 506 "/usr/include/stdio.h" 3 4
>extern int fgetc_unlocked (FILE *__stream);
># 517 "/usr/include/stdio.h" 3 4
>extern int fputc (int __c, FILE *__stream);
>extern int putc (int __c, FILE *__stream);
>
>
>
>
>
>extern int putchar (int __c);
># 537 "/usr/include/stdio.h" 3 4
>extern int fputc_unlocked (int __c, FILE *__stream);
>
>
>
>
>
>
>
>extern int putc_unlocked (int __c, FILE *__stream);
>extern int putchar_unlocked (int __c);
>
>
>
>
>
>
>extern int getw (FILE *__stream);
>
>
>extern int putw (int __w, FILE *__stream);
>
>
>
>
>
>
>
>extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
> ;
># 587 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
> FILE *__restrict __stream) ;
># 603 "/usr/include/stdio.h" 3 4
>extern __ssize_t __getdelim (char **__restrict __lineptr,
> size_t *__restrict __n, int __delimiter,
> FILE *__restrict __stream) ;
>extern __ssize_t getdelim (char **__restrict __lineptr,
> size_t *__restrict __n, int __delimiter,
> FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>extern __ssize_t getline (char **__restrict __lineptr,
> size_t *__restrict __n,
> FILE *__restrict __stream) ;
>
>
>
>
>
>
>
>extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
>
>
>
>
>
>extern int puts (const char *__s);
>
>
>
>
>
>
>extern int ungetc (int __c, FILE *__stream);
>
>
>
>
>
>
>extern size_t fread (void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>
>
>
>
>extern size_t fwrite (const void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __s);
># 662 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (const char *__restrict __s,
> FILE *__restrict __stream);
># 673 "/usr/include/stdio.h" 3 4
>extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream) ;
>extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
> size_t __n, FILE *__restrict __stream);
>
>
>
>
>
>
>
>extern int fseek (FILE *__stream, long int __off, int __whence);
>
>
>
>
>extern long int ftell (FILE *__stream) ;
>
>
>
>
>extern void rewind (FILE *__stream);
># 707 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream) ;
># 731 "/usr/include/stdio.h" 3 4
>extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
>
>
>
>
>extern int fsetpos (FILE *__stream, const fpos_t *__pos);
># 750 "/usr/include/stdio.h" 3 4
>extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
>extern __off64_t ftello64 (FILE *__stream) ;
>extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
>extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
>
>
>
>extern void clearerr (FILE *__stream) throw ();
>
>extern int feof (FILE *__stream) throw () ;
>
>extern int ferror (FILE *__stream) throw () ;
>
>
>
>extern void clearerr_unlocked (FILE *__stream) throw ();
>extern int feof_unlocked (FILE *__stream) throw () ;
>extern int ferror_unlocked (FILE *__stream) throw () ;
>
>
>
>
>
>
>
>extern void perror (const char *__s);
>
>
>
>
>
># 1 "/usr/include/bits/sys_errlist.h" 1 3 4
># 26 "/usr/include/bits/sys_errlist.h" 3 4
>extern int sys_nerr;
>extern const char *const sys_errlist[];
>
>
>extern int _sys_nerr;
>extern const char *const _sys_errlist[];
># 782 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>extern int fileno (FILE *__stream) throw () ;
>
>
>
>
>extern int fileno_unlocked (FILE *__stream) throw () ;
># 800 "/usr/include/stdio.h" 3 4
>extern FILE *popen (const char *__command, const char *__modes) ;
>
>
>
>
>
>extern int pclose (FILE *__stream);
>
>
>
>
>
>extern char *ctermid (char *__s) throw ();
>
>
>
>
>
>extern char *cuserid (char *__s);
>
>
>
>
>struct obstack;
>
>
>extern int obstack_printf (struct obstack *__restrict __obstack,
> const char *__restrict __format, ...)
> throw () __attribute__ ((__format__ (__printf__, 2, 3)));
>extern int obstack_vprintf (struct obstack *__restrict __obstack,
> const char *__restrict __format,
> __gnuc_va_list __args)
> throw () __attribute__ ((__format__ (__printf__, 2, 0)));
>
>
>
>
>
>
>
>extern void flockfile (FILE *__stream) throw ();
>
>
>
>extern int ftrylockfile (FILE *__stream) throw () ;
>
>
>extern void funlockfile (FILE *__stream) throw ();
># 859 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 35 "/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 _IO_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 _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fputc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar_unlocked (int __c)
>{
> return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
> return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x20) != 0);
>}
># 860 "/usr/include/stdio.h" 2 3 4
># 868 "/usr/include/stdio.h" 3 4
>}
># 43 "/usr/include/c++/8/cstdio" 2 3
># 96 "/usr/include/c++/8/cstdio" 3
>namespace std
>{
> using ::FILE;
> using ::fpos_t;
>
> using ::clearerr;
> using ::fclose;
> using ::feof;
> using ::ferror;
> using ::fflush;
> using ::fgetc;
> using ::fgetpos;
> using ::fgets;
> using ::fopen;
> using ::fprintf;
> using ::fputc;
> using ::fputs;
> using ::fread;
> using ::freopen;
> using ::fscanf;
> using ::fseek;
> using ::fsetpos;
> using ::ftell;
> using ::fwrite;
> using ::getc;
> using ::getchar;
>
>
>
>
> using ::perror;
> using ::printf;
> using ::putc;
> using ::putchar;
> using ::puts;
> using ::remove;
> using ::rename;
> using ::rewind;
> using ::scanf;
> using ::setbuf;
> using ::setvbuf;
> using ::sprintf;
> using ::sscanf;
> using ::tmpfile;
>
> using ::tmpnam;
>
> using ::ungetc;
> using ::vfprintf;
> using ::vprintf;
> using ::vsprintf;
>}
># 157 "/usr/include/c++/8/cstdio" 3
>namespace __gnu_cxx
>{
># 175 "/usr/include/c++/8/cstdio" 3
> using ::snprintf;
> using ::vfscanf;
> using ::vscanf;
> using ::vsnprintf;
> using ::vsscanf;
>
>}
>
>namespace std
>{
> using ::__gnu_cxx::snprintf;
> using ::__gnu_cxx::vfscanf;
> using ::__gnu_cxx::vscanf;
> using ::__gnu_cxx::vsnprintf;
> using ::__gnu_cxx::vsscanf;
>}
># 44 "/usr/include/c++/8/ext/string_conversions.h" 2 3
># 1 "/usr/include/c++/8/cerrno" 1 3
># 39 "/usr/include/c++/8/cerrno" 3
> 
># 40 "/usr/include/c++/8/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
># 1 "/usr/include/asm/errno.h" 2 3 4
># 1 "/usr/include/linux/errno.h" 2 3 4
># 27 "/usr/include/bits/errno.h" 2 3 4
># 29 "/usr/include/errno.h" 2 3 4
>
>
>
>
>
>extern "C" {
>
>
>extern int *__errno_location (void) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>
>extern char *program_invocation_name;
>extern char *program_invocation_short_name;
>
>
>
>
>
>typedef int error_t;
>
>
>
>
>}
># 43 "/usr/include/c++/8/cerrno" 2 3
># 45 "/usr/include/c++/8/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);
> }
>
>
>}
># 6362 "/usr/include/c++/8/bits/basic_string.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>namespace __cxx11 {
>
>
>
> inline int
> stoi(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
> __idx, __base); }
>
> inline long
> stol(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long
> stoul(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
> __idx, __base); }
>
> inline long long
> stoll(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long long
> stoull(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
> __idx, __base); }
>
>
> inline float
> stof(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
>
> inline double
> stod(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
>
> inline long double
> stold(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
>
>
>
>
>
>
> inline string
> to_string(int __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
> "%d", __val); }
>
> inline string
> to_string(unsigned __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned),
> "%u", __val); }
>
> inline string
> to_string(long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
> "%ld", __val); }
>
> inline string
> to_string(unsigned long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned long),
> "%lu", __val); }
>
> inline string
> to_string(long long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(long long),
> "%lld", __val); }
>
> inline string
> to_string(unsigned long long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned long long),
> "%llu", __val); }
>
> inline string
> to_string(float __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%f", __val);
> }
>
> inline string
> to_string(double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%f", __val);
> }
>
> inline string
> to_string(long double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%Lf", __val);
> }
>
>
>
> inline int
> stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
> __idx, __base); }
>
> inline long
> stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long
> stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
> __idx, __base); }
>
> inline long long
> stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long long
> stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
> __idx, __base); }
>
>
> inline float
> stof(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
>
> inline double
> stod(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
>
> inline long double
> stold(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
>
>
>
> inline wstring
> to_wstring(int __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
> L"%d", __val); }
>
> inline wstring
> to_wstring(unsigned __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned),
> L"%u", __val); }
>
> inline wstring
> to_wstring(long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
> L"%ld", __val); }
>
> inline wstring
> to_wstring(unsigned long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned long),
> L"%lu", __val); }
>
> inline wstring
> to_wstring(long long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(long long),
> L"%lld", __val); }
>
> inline wstring
> to_wstring(unsigned long long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned long long),
> L"%llu", __val); }
>
> inline wstring
> to_wstring(float __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%f", __val);
> }
>
> inline wstring
> to_wstring(double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%f", __val);
> }
>
> inline wstring
> to_wstring(long double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%Lf", __val);
> }
>
>
>
>}
>
>}
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> template<>
> struct hash<string>
> : public __hash_base<size_t, string>
> {
> size_t
> operator()(const string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(), __s.length()); }
> };
>
> template<>
> struct __is_fast_hash<hash<string>> : std::false_type
> { };
>
>
>
> template<>
> struct hash<wstring>
> : public __hash_base<size_t, wstring>
> {
> size_t
> operator()(const wstring& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(wchar_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<wstring>> : std::false_type
> { };
>
>
>
>
>
> template<>
> struct hash<u16string>
> : public __hash_base<size_t, u16string>
> {
> size_t
> operator()(const u16string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char16_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<u16string>> : std::false_type
> { };
>
>
> template<>
> struct hash<u32string>
> : public __hash_base<size_t, u32string>
> {
> size_t
> operator()(const u32string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char32_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<u32string>> : std::false_type
> { };
>
>
>
>
>
>
> inline namespace literals
> {
> inline namespace string_literals
> {
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wliteral-suffix"
> __attribute ((__abi_tag__ ("cxx11")))
> inline basic_string<char>
> operator""s(const char* __str, size_t __len)
> { return basic_string<char>{__str, __len}; }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> inline basic_string<wchar_t>
> operator""s(const wchar_t* __str, size_t __len)
> { return basic_string<wchar_t>{__str, __len}; }
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> inline basic_string<char16_t>
> operator""s(const char16_t* __str, size_t __len)
> { return basic_string<char16_t>{__str, __len}; }
>
> __attribute ((__abi_tag__ ("cxx11")))
> inline basic_string<char32_t>
> operator""s(const char32_t* __str, size_t __len)
> { return basic_string<char32_t>{__str, __len}; }
>
>
>#pragma GCC diagnostic pop
> }
> }
>
>
>
>
>}
># 53 "/usr/include/c++/8/string" 2 3
># 1 "/usr/include/c++/8/bits/basic_string.tcc" 1 3
># 42 "/usr/include/c++/8/bits/basic_string.tcc" 3
> 
># 43 "/usr/include/c++/8/bits/basic_string.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::npos;
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> swap(basic_string& __s) noexcept
> {
> if (this == &__s)
> return;
>
> _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
>
> if (_M_is_local())
> if (__s._M_is_local())
> {
> if (length() && __s.length())
> {
> _CharT __tmp_data[_S_local_capacity + 1];
> traits_type::copy(__tmp_data, __s._M_local_buf,
> _S_local_capacity + 1);
> traits_type::copy(__s._M_local_buf, _M_local_buf,
> _S_local_capacity + 1);
> traits_type::copy(_M_local_buf, __tmp_data,
> _S_local_capacity + 1);
> }
> else if (__s.length())
> {
> traits_type::copy(_M_local_buf, __s._M_local_buf,
> _S_local_capacity + 1);
> _M_length(__s.length());
> __s._M_set_length(0);
> return;
> }
> else if (length())
> {
> traits_type::copy(__s._M_local_buf, _M_local_buf,
> _S_local_capacity + 1);
> __s._M_length(length());
> _M_set_length(0);
> return;
> }
> }
> else
> {
> const size_type __tmp_capacity = __s._M_allocated_capacity;
> traits_type::copy(__s._M_local_buf, _M_local_buf,
> _S_local_capacity + 1);
> _M_data(__s._M_data());
> __s._M_data(__s._M_local_buf);
> _M_capacity(__tmp_capacity);
> }
> else
> {
> const size_type __tmp_capacity = _M_allocated_capacity;
> if (__s._M_is_local())
> {
> traits_type::copy(_M_local_buf, __s._M_local_buf,
> _S_local_capacity + 1);
> __s._M_data(_M_data());
> _M_data(_M_local_buf);
> }
> else
> {
> pointer __tmp_ptr = _M_data();
> _M_data(__s._M_data());
> __s._M_data(__tmp_ptr);
> _M_capacity(__s._M_allocated_capacity);
> }
> __s._M_capacity(__tmp_capacity);
> }
>
> const size_type __tmp_length = length();
> _M_length(__s.length());
> __s._M_length(__tmp_length);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::pointer
> basic_string<_CharT, _Traits, _Alloc>::
> _M_create(size_type& __capacity, size_type __old_capacity)
> {
>
>
> if (__capacity > max_size())
> std::__throw_length_error(("basic_string::_M_create"));
>
>
>
>
> if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
> {
> __capacity = 2 * __old_capacity;
>
> if (__capacity > max_size())
> __capacity = max_size();
> }
>
>
>
> return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
> }
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InIterator>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_construct(_InIterator __beg, _InIterator __end,
> std::input_iterator_tag)
> {
> size_type __len = 0;
> size_type __capacity = size_type(_S_local_capacity);
>
> while (__beg != __end && __len < __capacity)
> {
> _M_data()[__len++] = *__beg;
> ++__beg;
> }
>
> try
> {
> while (__beg != __end)
> {
> if (__len == __capacity)
> {
>
> __capacity = __len + 1;
> pointer __another = _M_create(__capacity, __len);
> this->_S_copy(__another, _M_data(), __len);
> _M_dispose();
> _M_data(__another);
> _M_capacity(__capacity);
> }
> _M_data()[__len++] = *__beg;
> ++__beg;
> }
> }
> catch(...)
> {
> _M_dispose();
> throw;
> }
>
> _M_set_length(__len);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InIterator>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_construct(_InIterator __beg, _InIterator __end,
> std::forward_iterator_tag)
> {
>
> if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
> std::__throw_logic_error(("basic_string::" "_M_construct null not valid")
> );
>
> size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
>
> if (__dnew > size_type(_S_local_capacity))
> {
> _M_data(_M_create(__dnew, size_type(0)));
> _M_capacity(__dnew);
> }
>
>
> try
> { this->_S_copy_chars(_M_data(), __beg, __end); }
> catch(...)
> {
> _M_dispose();
> throw;
> }
>
> _M_set_length(__dnew);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_construct(size_type __n, _CharT __c)
> {
> if (__n > size_type(_S_local_capacity))
> {
> _M_data(_M_create(__n, size_type(0)));
> _M_capacity(__n);
> }
>
> if (__n)
> this->_S_assign(_M_data(), __n, __c);
>
> _M_set_length(__n);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_assign(const basic_string& __str)
> {
> if (this != &__str)
> {
> const size_type __rsize = __str.length();
> const size_type __capacity = capacity();
>
> if (__rsize > __capacity)
> {
> size_type __new_capacity = __rsize;
> pointer __tmp = _M_create(__new_capacity, __capacity);
> _M_dispose();
> _M_data(__tmp);
> _M_capacity(__new_capacity);
> }
>
> if (__rsize)
> this->_S_copy(_M_data(), __str._M_data(), __rsize);
>
> _M_set_length(__rsize);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> reserve(size_type __res)
> {
>
> if (__res < length())
> __res = length();
>
> const size_type __capacity = capacity();
> if (__res != __capacity)
> {
> if (__res > __capacity
> || __res > size_type(_S_local_capacity))
> {
> pointer __tmp = _M_create(__res, __capacity);
> this->_S_copy(__tmp, _M_data(), length() + 1);
> _M_dispose();
> _M_data(__tmp);
> _M_capacity(__res);
> }
> else if (!_M_is_local())
> {
> this->_S_copy(_M_local_data(), _M_data(), length() + 1);
> _M_destroy(__capacity);
> _M_data(_M_local_data());
> }
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
> size_type __len2)
> {
> const size_type __how_much = length() - __pos - __len1;
>
> size_type __new_capacity = length() + __len2 - __len1;
> pointer __r = _M_create(__new_capacity, capacity());
>
> if (__pos)
> this->_S_copy(__r, _M_data(), __pos);
> if (__s && __len2)
> this->_S_copy(__r + __pos, __s, __len2);
> if (__how_much)
> this->_S_copy(__r + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
>
> _M_dispose();
> _M_data(__r);
> _M_capacity(__new_capacity);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_erase(size_type __pos, size_type __n)
> {
> const size_type __how_much = length() - __pos - __n;
>
> if (__how_much && __n)
> this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
>
> _M_set_length(length() - __n);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> resize(size_type __n, _CharT __c)
> {
> const size_type __size = this->size();
> if (__size < __n)
> this->append(__n - __size, __c);
> else if (__n < __size)
> this->_M_set_length(__n);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_append(const _CharT* __s, size_type __n)
> {
> const size_type __len = __n + this->size();
>
> if (__len <= this->capacity())
> {
> if (__n)
> this->_S_copy(this->_M_data() + this->size(), __s, __n);
> }
> else
> this->_M_mutate(this->size(), size_type(0), __s, __n);
>
> this->_M_set_length(__len);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
> _InputIterator __k1, _InputIterator __k2,
> std::__false_type)
> {
> const basic_string __s(__k1, __k2);
> const size_type __n1 = __i2 - __i1;
> return _M_replace(__i1 - begin(), __n1, __s._M_data(),
> __s.size());
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c)
> {
> _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
>
> const size_type __old_size = this->size();
> const size_type __new_size = __old_size + __n2 - __n1;
>
> if (__new_size <= this->capacity())
> {
> pointer __p = this->_M_data() + __pos1;
>
> const size_type __how_much = __old_size - __pos1 - __n1;
> if (__how_much && __n1 != __n2)
> this->_S_move(__p + __n2, __p + __n1, __how_much);
> }
> else
> this->_M_mutate(__pos1, __n1, 0, __n2);
>
> if (__n2)
> this->_S_assign(this->_M_data() + __pos1, __n2, __c);
>
> this->_M_set_length(__new_size);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
> const size_type __len2)
> {
> _M_check_length(__len1, __len2, "basic_string::_M_replace");
>
> const size_type __old_size = this->size();
> const size_type __new_size = __old_size + __len2 - __len1;
>
> if (__new_size <= this->capacity())
> {
> pointer __p = this->_M_data() + __pos;
>
> const size_type __how_much = __old_size - __pos - __len1;
> if (_M_disjunct(__s))
> {
> if (__how_much && __len1 != __len2)
> this->_S_move(__p + __len2, __p + __len1, __how_much);
> if (__len2)
> this->_S_copy(__p, __s, __len2);
> }
> else
> {
>
> if (__len2 && __len2 <= __len1)
> this->_S_move(__p, __s, __len2);
> if (__how_much && __len1 != __len2)
> this->_S_move(__p + __len2, __p + __len1, __how_much);
> if (__len2 > __len1)
> {
> if (__s + __len2 <= __p + __len1)
> this->_S_move(__p, __s, __len2);
> else if (__s >= __p + __len1)
> this->_S_copy(__p, __s + __len2 - __len1, __len2);
> else
> {
> const size_type __nleft = (__p + __len1) - __s;
> this->_S_move(__p, __s, __nleft);
> this->_S_copy(__p + __nleft, __p + __len2,
> __len2 - __nleft);
> }
> }
> }
> }
> else
> this->_M_mutate(__pos, __len1, __s, __len2);
>
> this->_M_set_length(__new_size);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> copy(_CharT* __s, size_type __n, size_type __pos) const
> {
> _M_check(__pos, "basic_string::copy");
> __n = _M_limit(__pos, __n);
> ;
> if (__n)
> _S_copy(__s, _M_data() + __pos, __n);
>
> return __n;
> }
># 1155 "/usr/include/c++/8/bits/basic_string.tcc" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> ;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> const __size_type __len = _Traits::length(__lhs);
> __string_type __str;
> __str.reserve(__len + __rhs.size());
> __str.append(__lhs, __len);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str;
> const __size_type __len = __rhs.size();
> __str.reserve(__len + 1);
> __str.append(__size_type(1), __lhs);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept
> {
> ;
> const size_type __size = this->size();
>
> if (__n == 0)
> return __pos <= __size ? __pos : npos;
> if (__pos >= __size)
> return npos;
>
> const _CharT __elem0 = __s[0];
> const _CharT* const __data = data();
> const _CharT* __first = __data + __pos;
> const _CharT* const __last = __data + __size;
> size_type __len = __size - __pos;
>
> while (__len >= __n)
> {
>
> __first = traits_type::find(__first, __len - __n + 1, __elem0);
> if (!__first)
> return npos;
>
>
>
> if (traits_type::compare(__first, __s, __n) == 0)
> return __first - __data;
> __len = __last - ++__first;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(_CharT __c, size_type __pos) const noexcept
> {
> size_type __ret = npos;
> const size_type __size = this->size();
> if (__pos < __size)
> {
> const _CharT* __data = _M_data();
> const size_type __n = __size - __pos;
> const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
> if (__p)
> __ret = __p - __data;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept
> {
> ;
> const size_type __size = this->size();
> if (__n <= __size)
> {
> __pos = std::min(size_type(__size - __n), __pos);
> const _CharT* __data = _M_data();
> do
> {
> if (traits_type::compare(__data + __pos, __s, __n) == 0)
> return __pos;
> }
> while (__pos-- > 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> for (++__size; __size-- > 0; )
> if (traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept
> {
> ;
> for (; __n && __pos < this->size(); ++__pos)
> {
> const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
> if (__p)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept
> {
> ;
> size_type __size = this->size();
> if (__size && __n)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size-- != 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept
> {
> ;
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::find(__s, __n, _M_data()[__pos]))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(_CharT __c, size_type __pos) const noexcept
> {
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::eq(_M_data()[__pos], __c))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> noexcept
> {
> ;
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n, const basic_string& __str) const
> {
> _M_check(__pos, "basic_string::compare");
> __n = _M_limit(__pos, __n);
> const size_type __osize = __str.size();
> const size_type __len = std::min(__n, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
> if (!__r)
> __r = _S_compare(__n, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const
> {
> _M_check(__pos1, "basic_string::compare");
> __str._M_check(__pos2, "basic_string::compare");
> __n1 = _M_limit(__pos1, __n1);
> __n2 = __str._M_limit(__pos2, __n2);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos1,
> __str.data() + __pos2, __len);
> if (!__r)
> __r = _S_compare(__n1, __n2);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(const _CharT* __s) const noexcept
> {
> ;
> const size_type __size = this->size();
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__size, __osize);
> int __r = traits_type::compare(_M_data(), __s, __len);
> if (!__r)
> __r = _S_compare(__size, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__n1, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = _S_compare(__n1, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = _S_compare(__n1, __n2);
> return __r;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __istream_type::ios_base __ios_base;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __string_type::size_type __size_type;
> typedef ctype<_CharT> __ctype_type;
> typedef typename __ctype_type::ctype_base __ctype_base;
>
> __size_type __extracted = 0;
> typename __ios_base::iostate __err = __ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> __str.erase();
> _CharT __buf[128];
> __size_type __len = 0;
> const streamsize __w = __in.width();
> const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
> : __str.max_size();
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __int_type __c = __in.rdbuf()->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(__ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> if (__len == sizeof(__buf) / sizeof(_CharT))
> {
> __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
> __len = 0;
> }
> __buf[__len++] = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __in.rdbuf()->snextc();
> }
> __str.append(__buf, __len);
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= __ios_base::eofbit;
> __in.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(__ios_base::badbit);
> }
> }
>
> if (!__extracted)
> __err |= __ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __istream_type::ios_base __ios_base;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> const __size_type __n = __str.max_size();
> typename __ios_base::iostate __err = __ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, true);
> if (__cerb)
> {
> try
> {
> __str.erase();
> const __int_type __idelim = _Traits::to_int_type(__delim);
> const __int_type __eof = _Traits::eof();
> __int_type __c = __in.rdbuf()->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !_Traits::eq_int_type(__c, __idelim))
> {
> __str += _Traits::to_char_type(__c);
> ++__extracted;
> __c = __in.rdbuf()->snextc();
> }
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= __ios_base::eofbit;
> else if (_Traits::eq_int_type(__c, __idelim))
> {
> ++__extracted;
> __in.rdbuf()->sbumpc();
> }
> else
> __err |= __ios_base::failbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(__ios_base::badbit);
> }
> }
> if (!__extracted)
> __err |= __ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
># 1632 "/usr/include/c++/8/bits/basic_string.tcc" 3
>
>}
># 54 "/usr/include/c++/8/string" 2 3
># 41 "/usr/include/c++/8/bits/locale_classes.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 62 "/usr/include/c++/8/bits/locale_classes.h" 3
> class locale
> {
> public:
>
>
> typedef int category;
>
>
> class facet;
> class id;
> class _Impl;
>
> friend class facet;
> friend class _Impl;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
># 98 "/usr/include/c++/8/bits/locale_classes.h" 3
> static const category none = 0;
> static const category ctype = 1L << 0;
> static const category numeric = 1L << 1;
> static const category collate = 1L << 2;
> static const category time = 1L << 3;
> static const category monetary = 1L << 4;
> static const category messages = 1L << 5;
> static const category all = (ctype | numeric | collate |
> time | monetary | messages);
># 117 "/usr/include/c++/8/bits/locale_classes.h" 3
> locale() throw();
># 126 "/usr/include/c++/8/bits/locale_classes.h" 3
> locale(const locale& __other) throw();
># 136 "/usr/include/c++/8/bits/locale_classes.h" 3
> explicit
> locale(const char* __s);
># 151 "/usr/include/c++/8/bits/locale_classes.h" 3
> locale(const locale& __base, const char* __s, category __cat);
># 162 "/usr/include/c++/8/bits/locale_classes.h" 3
> explicit
> locale(const std::string& __s) : locale(__s.c_str()) { }
># 177 "/usr/include/c++/8/bits/locale_classes.h" 3
> locale(const locale& __base, const std::string& __s, category __cat)
> : locale(__base, __s.c_str(), __cat) { }
># 192 "/usr/include/c++/8/bits/locale_classes.h" 3
> locale(const locale& __base, const locale& __add, category __cat);
># 205 "/usr/include/c++/8/bits/locale_classes.h" 3
> template<typename _Facet>
> locale(const locale& __other, _Facet* __f);
>
>
> ~locale() throw();
># 219 "/usr/include/c++/8/bits/locale_classes.h" 3
> const locale&
> operator=(const locale& __other) throw();
># 234 "/usr/include/c++/8/bits/locale_classes.h" 3
> template<typename _Facet>
> locale
> combine(const locale& __other) const;
>
>
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> string
> name() const;
># 254 "/usr/include/c++/8/bits/locale_classes.h" 3
> bool
> operator==(const locale& __other) const throw();
>
>
>
>
>
>
>
> bool
> operator!=(const locale& __other) const throw()
> { return !(this->operator==(__other)); }
># 282 "/usr/include/c++/8/bits/locale_classes.h" 3
> template<typename _Char, typename _Traits, typename _Alloc>
> bool
> operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
> const basic_string<_Char, _Traits, _Alloc>& __s2) const;
># 298 "/usr/include/c++/8/bits/locale_classes.h" 3
> static locale
> global(const locale& __loc);
>
>
>
>
> static const locale&
> classic();
>
> private:
>
> _Impl* _M_impl;
>
>
> static _Impl* _S_classic;
>
>
> static _Impl* _S_global;
>
>
>
>
>
> static const char* const* const _S_categories;
># 333 "/usr/include/c++/8/bits/locale_classes.h" 3
> enum { _S_categories_size = 6 + 6 };
>
>
> static __gthread_once_t _S_once;
>
>
> explicit
> locale(_Impl*) throw();
>
> static void
> _S_initialize();
>
> static void
> _S_initialize_once() throw();
>
> static category
> _S_normalize_category(category);
>
> void
> _M_coalesce(const locale& __base, const locale& __add, category __cat);
>
>
> static const id* const _S_twinned_facets[];
>
> };
># 371 "/usr/include/c++/8/bits/locale_classes.h" 3
> class locale::facet
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> mutable _Atomic_word _M_refcount;
>
>
> static __c_locale _S_c_locale;
>
>
> static const char _S_c_name[2];
>
>
> static __gthread_once_t _S_once;
>
>
> static void
> _S_initialize_once();
>
> protected:
># 402 "/usr/include/c++/8/bits/locale_classes.h" 3
> explicit
> facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
> { }
>
>
> virtual
> ~facet();
>
> static void
> _S_create_c_locale(__c_locale& __cloc, const char* __s,
> __c_locale __old = 0);
>
> static __c_locale
> _S_clone_c_locale(__c_locale& __cloc) throw();
>
> static void
> _S_destroy_c_locale(__c_locale& __cloc);
>
> static __c_locale
> _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
>
>
>
> static __c_locale
> _S_get_c_locale();
>
> __attribute__ ((__const__)) static const char*
> _S_get_c_name() throw();
># 438 "/usr/include/c++/8/bits/locale_classes.h" 3
> facet(const facet&) = delete;
>
> facet&
> operator=(const facet&) = delete;
>
>
> private:
> void
> _M_add_reference() const throw()
> { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
> void
> _M_remove_reference() const throw()
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
> ;
> try
> { delete this; }
> catch(...)
> { }
> }
> }
>
> const facet* _M_sso_shim(const id*) const;
> const facet* _M_cow_shim(const id*) const;
>
> protected:
> class __shim;
> };
># 483 "/usr/include/c++/8/bits/locale_classes.h" 3
> class locale::id
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
>
>
>
> mutable size_t _M_index;
>
>
> static _Atomic_word _S_refcount;
>
> void
> operator=(const id&);
>
> id(const id&);
>
> public:
>
>
>
> id() { }
>
> size_t
> _M_id() const throw();
> };
>
>
>
> class locale::_Impl
> {
> public:
>
> friend class locale;
> friend class locale::facet;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
>
> private:
>
> _Atomic_word _M_refcount;
> const facet** _M_facets;
> size_t _M_facets_size;
> const facet** _M_caches;
> char** _M_names;
> static const locale::id* const _S_id_ctype[];
> static const locale::id* const _S_id_numeric[];
> static const locale::id* const _S_id_collate[];
> static const locale::id* const _S_id_time[];
> static const locale::id* const _S_id_monetary[];
> static const locale::id* const _S_id_messages[];
> static const locale::id* const* const _S_facet_categories[];
>
> void
> _M_add_reference() throw()
> { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
> void
> _M_remove_reference() throw()
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
> ;
> try
> { delete this; }
> catch(...)
> { }
> }
> }
>
> _Impl(const _Impl&, size_t);
> _Impl(const char*, size_t);
> _Impl(size_t) throw();
>
> ~_Impl() throw();
>
> _Impl(const _Impl&);
>
> void
> operator=(const _Impl&);
>
> bool
> _M_check_same_name()
> {
> bool __ret = true;
> if (_M_names[1])
>
> for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
> __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
> return __ret;
> }
>
> void
> _M_replace_categories(const _Impl*, category);
>
> void
> _M_replace_category(const _Impl*, const locale::id* const*);
>
> void
> _M_replace_facet(const _Impl*, const locale::id*);
>
> void
> _M_install_facet(const locale::id*, const facet*);
>
> template<typename _Facet>
> void
> _M_init_facet(_Facet* __facet)
> { _M_install_facet(&_Facet::id, __facet); }
>
> template<typename _Facet>
> void
> _M_init_facet_unchecked(_Facet* __facet)
> {
> __facet->_M_add_reference();
> _M_facets[_Facet::id._M_id()] = __facet;
> }
>
> void
> _M_install_cache(const facet*, size_t);
>
> void _M_init_extra(facet**);
> void _M_init_extra(void*, void*, const char*, const char*);
> };
># 641 "/usr/include/c++/8/bits/locale_classes.h" 3
> template<typename _CharT>
> class __cxx11:: collate : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> protected:
>
>
> __c_locale _M_c_locale_collate;
>
> public:
>
> static locale::id id;
># 668 "/usr/include/c++/8/bits/locale_classes.h" 3
> explicit
> collate(size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
> { }
># 682 "/usr/include/c++/8/bits/locale_classes.h" 3
> explicit
> collate(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
> { }
># 699 "/usr/include/c++/8/bits/locale_classes.h" 3
> int
> compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const
> { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
># 718 "/usr/include/c++/8/bits/locale_classes.h" 3
> string_type
> transform(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_transform(__lo, __hi); }
># 732 "/usr/include/c++/8/bits/locale_classes.h" 3
> long
> hash(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_hash(__lo, __hi); }
>
>
> int
> _M_compare(const _CharT*, const _CharT*) const throw();
>
> size_t
> _M_transform(_CharT*, const _CharT*, size_t) const throw();
>
> protected:
>
> virtual
> ~collate()
> { _S_destroy_c_locale(_M_c_locale_collate); }
># 761 "/usr/include/c++/8/bits/locale_classes.h" 3
> virtual int
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const;
># 775 "/usr/include/c++/8/bits/locale_classes.h" 3
> virtual string_type
> do_transform(const _CharT* __lo, const _CharT* __hi) const;
># 788 "/usr/include/c++/8/bits/locale_classes.h" 3
> virtual long
> do_hash(const _CharT* __lo, const _CharT* __hi) const;
> };
>
> template<typename _CharT>
> locale::id collate<_CharT>::id;
>
>
> template<>
> int
> collate<char>::_M_compare(const char*, const char*) const throw();
>
> template<>
> size_t
> collate<char>::_M_transform(char*, const char*, size_t) const throw();
>
>
> template<>
> int
> collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
>
> template<>
> size_t
> collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
>
>
>
> template<typename _CharT>
> class __cxx11:: collate_byname : public collate<_CharT>
> {
> public:
>
>
> typedef _CharT char_type;
> typedef basic_string<_CharT> string_type;
>
>
> explicit
> collate_byname(const char* __s, size_t __refs = 0)
> : collate<_CharT>(__refs)
> {
> if (__builtin_strcmp(__s, "C") != 0
> && __builtin_strcmp(__s, "POSIX") != 0)
> {
> this->_S_destroy_c_locale(this->_M_c_locale_collate);
> this->_S_create_c_locale(this->_M_c_locale_collate, __s);
> }
> }
>
>
> explicit
> collate_byname(const string& __s, size_t __refs = 0)
> : collate_byname(__s.c_str(), __refs) { }
>
>
> protected:
> virtual
> ~collate_byname() { }
> };
>
>
>}
>
># 1 "/usr/include/c++/8/bits/locale_classes.tcc" 1 3
># 37 "/usr/include/c++/8/bits/locale_classes.tcc" 3
> 
># 38 "/usr/include/c++/8/bits/locale_classes.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Facet>
> locale::
> locale(const locale& __other, _Facet* __f)
> {
> _M_impl = new _Impl(*__other._M_impl, 1);
>
> try
> { _M_impl->_M_install_facet(&_Facet::id, __f); }
> catch(...)
> {
> _M_impl->_M_remove_reference();
> throw;
> }
> delete [] _M_impl->_M_names[0];
> _M_impl->_M_names[0] = 0;
> }
>
> template<typename _Facet>
> locale
> locale::
> combine(const locale& __other) const
> {
> _Impl* __tmp = new _Impl(*_M_impl, 1);
> try
> {
> __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
> }
> catch(...)
> {
> __tmp->_M_remove_reference();
> throw;
> }
> return locale(__tmp);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> bool
> locale::
> operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
> const basic_string<_CharT, _Traits, _Alloc>& __s2) const
> {
> typedef std::collate<_CharT> __collate_type;
> const __collate_type& __collate = use_facet<__collate_type>(*this);
> return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
> __s2.data(), __s2.data() + __s2.length()) < 0);
> }
># 102 "/usr/include/c++/8/bits/locale_classes.tcc" 3
> template<typename _Facet>
> bool
> has_facet(const locale& __loc) throw()
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> return (__i < __loc._M_impl->_M_facets_size
>
> && dynamic_cast<const _Facet*>(__facets[__i]));
>
>
>
> }
># 130 "/usr/include/c++/8/bits/locale_classes.tcc" 3
> template<typename _Facet>
> const _Facet&
> use_facet(const locale& __loc)
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
> __throw_bad_cast();
>
> return dynamic_cast<const _Facet&>(*__facets[__i]);
>
>
>
> }
>
>
>
> template<typename _CharT>
> int
> collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
> { return 0; }
>
>
> template<typename _CharT>
> size_t
> collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
> { return 0; }
>
> template<typename _CharT>
> int
> collate<_CharT>::
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const
> {
>
>
> const string_type __one(__lo1, __hi1);
> const string_type __two(__lo2, __hi2);
>
> const _CharT* __p = __one.c_str();
> const _CharT* __pend = __one.data() + __one.length();
> const _CharT* __q = __two.c_str();
> const _CharT* __qend = __two.data() + __two.length();
>
>
>
>
> for (;;)
> {
> const int __res = _M_compare(__p, __q);
> if (__res)
> return __res;
>
> __p += char_traits<_CharT>::length(__p);
> __q += char_traits<_CharT>::length(__q);
> if (__p == __pend && __q == __qend)
> return 0;
> else if (__p == __pend)
> return -1;
> else if (__q == __qend)
> return 1;
>
> __p++;
> __q++;
> }
> }
>
> template<typename _CharT>
> typename collate<_CharT>::string_type
> collate<_CharT>::
> do_transform(const _CharT* __lo, const _CharT* __hi) const
> {
> string_type __ret;
>
>
> const string_type __str(__lo, __hi);
>
> const _CharT* __p = __str.c_str();
> const _CharT* __pend = __str.data() + __str.length();
>
> size_t __len = (__hi - __lo) * 2;
>
> _CharT* __c = new _CharT[__len];
>
> try
> {
>
>
>
> for (;;)
> {
>
> size_t __res = _M_transform(__c, __p, __len);
>
>
> if (__res >= __len)
> {
> __len = __res + 1;
> delete [] __c, __c = 0;
> __c = new _CharT[__len];
> __res = _M_transform(__c, __p, __len);
> }
>
> __ret.append(__c, __res);
> __p += char_traits<_CharT>::length(__p);
> if (__p == __pend)
> break;
>
> __p++;
> __ret.push_back(_CharT());
> }
> }
> catch(...)
> {
> delete [] __c;
> throw;
> }
>
> delete [] __c;
>
> return __ret;
> }
>
> template<typename _CharT>
> long
> collate<_CharT>::
> do_hash(const _CharT* __lo, const _CharT* __hi) const
> {
> unsigned long __val = 0;
> for (; __lo < __hi; ++__lo)
> __val =
> *__lo + ((__val << 7)
> | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
> __digits - 7)));
> return static_cast<long>(__val);
> }
>
>
>
>
> extern template class collate<char>;
> extern template class collate_byname<char>;
>
> extern template
> const collate<char>&
> use_facet<collate<char> >(const locale&);
>
> extern template
> bool
> has_facet<collate<char> >(const locale&);
>
>
> extern template class collate<wchar_t>;
> extern template class collate_byname<wchar_t>;
>
> extern template
> const collate<wchar_t>&
> use_facet<collate<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<wchar_t> >(const locale&);
>
>
>
>
>}
># 852 "/usr/include/c++/8/bits/locale_classes.h" 2 3
># 42 "/usr/include/c++/8/bits/ios_base.h" 2 3
>
>
>
>
># 1 "/usr/include/c++/8/system_error" 1 3
># 32 "/usr/include/c++/8/system_error" 3
> 
># 33 "/usr/include/c++/8/system_error" 3
>
>
>
>
>
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h" 1 3
># 34 "/usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h" 3
># 1 "/usr/include/c++/8/cerrno" 1 3
># 39 "/usr/include/c++/8/cerrno" 3
> 
># 40 "/usr/include/c++/8/cerrno" 3
># 35 "/usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> enum class errc
> {
> address_family_not_supported = 97,
> address_in_use = 98,
> address_not_available = 99,
> already_connected = 106,
> argument_list_too_long = 7,
> argument_out_of_domain = 33,
> bad_address = 14,
> bad_file_descriptor = 9,
>
>
> bad_message = 74,
>
>
> broken_pipe = 32,
> connection_aborted = 103,
> connection_already_in_progress = 114,
> connection_refused = 111,
> connection_reset = 104,
> cross_device_link = 18,
> destination_address_required = 89,
> device_or_resource_busy = 16,
> directory_not_empty = 39,
> executable_format_error = 8,
> file_exists = 17,
> file_too_large = 27,
> filename_too_long = 36,
> function_not_supported = 38,
> host_unreachable = 113,
>
>
> identifier_removed = 43,
>
>
> illegal_byte_sequence = 84,
> inappropriate_io_control_operation = 25,
> interrupted = 4,
> invalid_argument = 22,
> invalid_seek = 29,
> io_error = 5,
> is_a_directory = 21,
> message_size = 90,
> network_down = 100,
> network_reset = 102,
> network_unreachable = 101,
> no_buffer_space = 105,
> no_child_process = 10,
>
>
> no_link = 67,
>
>
> no_lock_available = 37,
>
>
> no_message_available = 61,
>
>
> no_message = 42,
> no_protocol_option = 92,
> no_space_on_device = 28,
>
>
> no_stream_resources = 63,
>
>
> no_such_device_or_address = 6,
> no_such_device = 19,
> no_such_file_or_directory = 2,
> no_such_process = 3,
> not_a_directory = 20,
> not_a_socket = 88,
>
>
> not_a_stream = 60,
>
>
> not_connected = 107,
> not_enough_memory = 12,
>
>
> not_supported = 95,
>
>
>
> operation_canceled = 125,
>
>
> operation_in_progress = 115,
> operation_not_permitted = 1,
> operation_not_supported = 95,
> operation_would_block = 11,
>
>
> owner_dead = 130,
>
>
> permission_denied = 13,
>
>
> protocol_error = 71,
>
>
> protocol_not_supported = 93,
> read_only_file_system = 30,
> resource_deadlock_would_occur = 35,
> resource_unavailable_try_again = 11,
> result_out_of_range = 34,
>
>
> state_not_recoverable = 131,
>
>
>
> stream_timeout = 62,
>
>
>
> text_file_busy = 26,
>
>
> timed_out = 110,
> too_many_files_open_in_system = 23,
> too_many_files_open = 24,
> too_many_links = 31,
> too_many_symbolic_link_levels = 40,
>
>
> value_too_large = 75,
>
>
> wrong_protocol_type = 91
> };
>
>
>}
># 40 "/usr/include/c++/8/system_error" 2 3
>
># 1 "/usr/include/c++/8/stdexcept" 1 3
># 36 "/usr/include/c++/8/stdexcept" 3
> 
># 37 "/usr/include/c++/8/stdexcept" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
> struct __cow_string
> {
> union {
> const char* _M_p;
> char _M_bytes[sizeof(const char*)];
> };
>
> __cow_string();
> __cow_string(const std::string&);
> __cow_string(const char*, size_t);
> __cow_string(const __cow_string&) noexcept;
> __cow_string& operator=(const __cow_string&) noexcept;
> ~__cow_string();
>
> __cow_string(__cow_string&&) noexcept;
> __cow_string& operator=(__cow_string&&) noexcept;
>
> };
>
> typedef basic_string<char> __sso_string;
># 113 "/usr/include/c++/8/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(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*) ;
>
> virtual ~domain_error() noexcept;
> };
>
>
> class invalid_argument : public logic_error
> {
> public:
> explicit invalid_argument(const string& __arg) ;
>
> explicit invalid_argument(const char*) ;
>
> virtual ~invalid_argument() noexcept;
> };
>
>
>
> class length_error : public logic_error
> {
> public:
> explicit length_error(const string& __arg) ;
>
> explicit length_error(const char*) ;
>
> 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*) ;
>
> 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(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*) ;
>
> virtual ~range_error() noexcept;
> };
>
>
> class overflow_error : public runtime_error
> {
> public:
> explicit overflow_error(const string& __arg) ;
>
> explicit overflow_error(const char*) ;
>
> virtual ~overflow_error() noexcept;
> };
>
>
> class underflow_error : public runtime_error
> {
> public:
> explicit underflow_error(const string& __arg) ;
>
> explicit underflow_error(const char*) ;
>
> virtual ~underflow_error() noexcept;
> };
>
>
>
>
>}
># 42 "/usr/include/c++/8/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 {
>
>
> 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;
># 110 "/usr/include/c++/8/system_error" 3
> public:
> virtual error_condition
> default_error_condition(int __i) const noexcept;
>
> virtual bool
> equivalent(int __i, const error_condition& __cond) const noexcept;
>
> virtual bool
> equivalent(const error_code& __code, int __i) const noexcept;
>
> bool
> operator<(const error_category& __other) const noexcept
> { return less<const error_category*>()(this, &__other); }
>
> bool
> operator==(const error_category& __other) const noexcept
> { return this == &__other; }
>
> bool
> operator!=(const error_category& __other) const noexcept
> { return this != &__other; }
> };
>
>
> __attribute__ ((__const__)) const error_category& system_category() noexcept;
> __attribute__ ((__const__)) const error_category& generic_category() noexcept;
>
> }
>
> error_code make_error_code(errc) noexcept;
>
> template<typename _Tp>
> struct hash;
>
>
>
> struct error_code
> {
> error_code() noexcept
> : _M_value(0), _M_cat(&system_category()) { }
>
> error_code(int __v, const error_category& __cat) noexcept
> : _M_value(__v), _M_cat(&__cat) { }
>
> template<typename _ErrorCodeEnum, typename = typename
> enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
> error_code(_ErrorCodeEnum __e) noexcept
> { *this = make_error_code(__e); }
>
> void
> assign(int __v, const error_category& __cat) noexcept
> {
> _M_value = __v;
> _M_cat = &__cat;
> }
>
> void
> clear() noexcept
> { assign(0, system_category()); }
>
>
> template<typename _ErrorCodeEnum>
> typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
> error_code&>::type
> operator=(_ErrorCodeEnum __e) noexcept
> { return *this = make_error_code(__e); }
>
> int
> value() const noexcept { return _M_value; }
>
> const error_category&
> category() const noexcept { return *_M_cat; }
>
> error_condition
> default_error_condition() const noexcept;
>
> __attribute ((__abi_tag__ ("cxx11")))
> string
> message() const
> { return category().message(value()); }
>
> explicit operator bool() const noexcept
> { return _M_value != 0; }
>
>
> private:
> friend class hash<error_code>;
>
> int _M_value;
> const error_category* _M_cat;
> };
>
>
> inline error_code
> make_error_code(errc __e) noexcept
> { return error_code(static_cast<int>(__e), generic_category()); }
>
> inline bool
> operator<(const error_code& __lhs, const error_code& __rhs) noexcept
> {
> return (__lhs.category() < __rhs.category()
> || (__lhs.category() == __rhs.category()
> && __lhs.value() < __rhs.value()));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
> { return (__os << __e.category().name() << ':' << __e.value()); }
>
> error_condition make_error_condition(errc) noexcept;
>
>
>
> struct error_condition
> {
> error_condition() noexcept
> : _M_value(0), _M_cat(&generic_category()) { }
>
> error_condition(int __v, const error_category& __cat) noexcept
> : _M_value(__v), _M_cat(&__cat) { }
>
> template<typename _ErrorConditionEnum, typename = typename
> enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
> error_condition(_ErrorConditionEnum __e) noexcept
> { *this = make_error_condition(__e); }
>
> void
> assign(int __v, const error_category& __cat) noexcept
> {
> _M_value = __v;
> _M_cat = &__cat;
> }
>
>
> template<typename _ErrorConditionEnum>
> typename enable_if<is_error_condition_enum
> <_ErrorConditionEnum>::value, error_condition&>::type
> operator=(_ErrorConditionEnum __e) noexcept
> { return *this = make_error_condition(__e); }
>
> void
> clear() noexcept
> { assign(0, generic_category()); }
>
>
> int
> value() const noexcept { return _M_value; }
>
> const error_category&
> category() const noexcept { return *_M_cat; }
>
> __attribute ((__abi_tag__ ("cxx11")))
> string
> message() const
> { return category().message(value()); }
>
> explicit operator bool() const noexcept
> { return _M_value != 0; }
>
>
> private:
> int _M_value;
> const error_category* _M_cat;
> };
>
>
> inline error_condition
> make_error_condition(errc __e) noexcept
> { return error_condition(static_cast<int>(__e), generic_category()); }
>
> inline bool
> operator<(const error_condition& __lhs,
> const error_condition& __rhs) noexcept
> {
> return (__lhs.category() < __rhs.category()
> || (__lhs.category() == __rhs.category()
> && __lhs.value() < __rhs.value()));
> }
>
>
> inline bool
> operator==(const error_code& __lhs, const error_code& __rhs) noexcept
> { return (__lhs.category() == __rhs.category()
> && __lhs.value() == __rhs.value()); }
>
> inline bool
> operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
> {
> return (__lhs.category().equivalent(__lhs.value(), __rhs)
> || __rhs.category().equivalent(__lhs, __rhs.value()));
> }
>
> inline bool
> operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
> {
> return (__rhs.category().equivalent(__rhs.value(), __lhs)
> || __lhs.category().equivalent(__rhs, __lhs.value()));
> }
>
> inline bool
> operator==(const error_condition& __lhs,
> const error_condition& __rhs) noexcept
> {
> return (__lhs.category() == __rhs.category()
> && __lhs.value() == __rhs.value());
> }
>
> inline bool
> operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
> { return !(__lhs == __rhs); }
>
> inline bool
> operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
> { return !(__lhs == __rhs); }
>
> inline bool
> operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
> { return !(__lhs == __rhs); }
>
> inline bool
> operator!=(const error_condition& __lhs,
> const error_condition& __rhs) noexcept
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> 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) { }
>
> 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._M_value);
> return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
> }
> };
>
>
>
>
>
> template<>
> struct hash<error_condition>
> : public __hash_base<size_t, error_condition>
> {
> size_t
> operator()(const error_condition& __e) const noexcept
> {
> const size_t __tmp = std::_Hash_impl::hash(__e.value());
> return std::_Hash_impl::__hash_combine(__e.category(), __tmp);
> }
> };
>
>
>
>}
># 47 "/usr/include/c++/8/bits/ios_base.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> enum _Ios_Fmtflags
> {
> _S_boolalpha = 1L << 0,
> _S_dec = 1L << 1,
> _S_fixed = 1L << 2,
> _S_hex = 1L << 3,
> _S_internal = 1L << 4,
> _S_left = 1L << 5,
> _S_oct = 1L << 6,
> _S_right = 1L << 7,
> _S_scientific = 1L << 8,
> _S_showbase = 1L << 9,
> _S_showpoint = 1L << 10,
> _S_showpos = 1L << 11,
> _S_skipws = 1L << 12,
> _S_unitbuf = 1L << 13,
> _S_uppercase = 1L << 14,
> _S_adjustfield = _S_left | _S_right | _S_internal,
> _S_basefield = _S_dec | _S_oct | _S_hex,
> _S_floatfield = _S_scientific | _S_fixed,
> _S_ios_fmtflags_end = 1L << 16,
> _S_ios_fmtflags_max = 0x7fffffff,
> _S_ios_fmtflags_min = ~0x7fffffff
> };
>
> inline constexpr _Ios_Fmtflags
> operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator~(_Ios_Fmtflags __a)
> { return _Ios_Fmtflags(~static_cast<int>(__a)); }
>
> inline const _Ios_Fmtflags&
> operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a | __b; }
>
> inline const _Ios_Fmtflags&
> operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a & __b; }
>
> inline const _Ios_Fmtflags&
> operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
> { return __a = __a ^ __b; }
>
>
> enum _Ios_Openmode
> {
> _S_app = 1L << 0,
> _S_ate = 1L << 1,
> _S_bin = 1L << 2,
> _S_in = 1L << 3,
> _S_out = 1L << 4,
> _S_trunc = 1L << 5,
> _S_ios_openmode_end = 1L << 16,
> _S_ios_openmode_max = 0x7fffffff,
> _S_ios_openmode_min = ~0x7fffffff
> };
>
> inline constexpr _Ios_Openmode
> operator&(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator|(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator^(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator~(_Ios_Openmode __a)
> { return _Ios_Openmode(~static_cast<int>(__a)); }
>
> inline const _Ios_Openmode&
> operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a | __b; }
>
> inline const _Ios_Openmode&
> operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a & __b; }
>
> inline const _Ios_Openmode&
> operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
> { return __a = __a ^ __b; }
>
>
> enum _Ios_Iostate
> {
> _S_goodbit = 0,
> _S_badbit = 1L << 0,
> _S_eofbit = 1L << 1,
> _S_failbit = 1L << 2,
> _S_ios_iostate_end = 1L << 16,
> _S_ios_iostate_max = 0x7fffffff,
> _S_ios_iostate_min = ~0x7fffffff
> };
>
> inline constexpr _Ios_Iostate
> operator&(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator|(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator^(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator~(_Ios_Iostate __a)
> { return _Ios_Iostate(~static_cast<int>(__a)); }
>
> inline const _Ios_Iostate&
> operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a | __b; }
>
> inline const _Ios_Iostate&
> operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a & __b; }
>
> inline const _Ios_Iostate&
> operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
> { return __a = __a ^ __b; }
>
>
> enum _Ios_Seekdir
> {
> _S_beg = 0,
> _S_cur = 1,
> _S_end = 2,
> _S_ios_seekdir_end = 1L << 16
> };
>
>
>
> enum class io_errc { stream = 1 };
>
> template <> struct is_error_code_enum<io_errc> : public true_type { };
>
> const error_category& iostream_category() noexcept;
>
> inline error_code
> make_error_code(io_errc __e) noexcept
> { return error_code(static_cast<int>(__e), iostream_category()); }
>
> inline error_condition
> make_error_condition(io_errc __e) noexcept
> { return error_condition(static_cast<int>(__e), iostream_category()); }
># 228 "/usr/include/c++/8/bits/ios_base.h" 3
> class ios_base
> {
># 246 "/usr/include/c++/8/bits/ios_base.h" 3
> public:
># 255 "/usr/include/c++/8/bits/ios_base.h" 3
> class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
> {
> public:
> explicit
> failure(const string& __str);
>
>
> explicit
> failure(const string&, const error_code&);
>
> explicit
> failure(const char*, const error_code& = io_errc::stream);
>
>
> virtual
> ~failure() throw();
>
> virtual const char*
> what() const throw();
> };
># 323 "/usr/include/c++/8/bits/ios_base.h" 3
> typedef _Ios_Fmtflags fmtflags;
>
>
> static const fmtflags boolalpha = _S_boolalpha;
>
>
> static const fmtflags dec = _S_dec;
>
>
> static const fmtflags fixed = _S_fixed;
>
>
> static const fmtflags hex = _S_hex;
>
>
>
>
> static const fmtflags internal = _S_internal;
>
>
>
> static const fmtflags left = _S_left;
>
>
> static const fmtflags oct = _S_oct;
>
>
>
> static const fmtflags right = _S_right;
>
>
> static const fmtflags scientific = _S_scientific;
>
>
>
> static const fmtflags showbase = _S_showbase;
>
>
>
> static const fmtflags showpoint = _S_showpoint;
>
>
> static const fmtflags showpos = _S_showpos;
>
>
> static const fmtflags skipws = _S_skipws;
>
>
> static const fmtflags unitbuf = _S_unitbuf;
>
>
>
> static const fmtflags uppercase = _S_uppercase;
>
>
> static const fmtflags adjustfield = _S_adjustfield;
>
>
> static const fmtflags basefield = _S_basefield;
>
>
> static const fmtflags floatfield = _S_floatfield;
># 398 "/usr/include/c++/8/bits/ios_base.h" 3
> typedef _Ios_Iostate iostate;
>
>
>
> static const iostate badbit = _S_badbit;
>
>
> static const iostate eofbit = _S_eofbit;
>
>
>
>
> static const iostate failbit = _S_failbit;
>
>
> static const iostate goodbit = _S_goodbit;
># 429 "/usr/include/c++/8/bits/ios_base.h" 3
> typedef _Ios_Openmode openmode;
>
>
> static const openmode app = _S_app;
>
>
> static const openmode ate = _S_ate;
>
>
>
>
> static const openmode binary = _S_bin;
>
>
> static const openmode in = _S_in;
>
>
> static const openmode out = _S_out;
>
>
> static const openmode trunc = _S_trunc;
># 461 "/usr/include/c++/8/bits/ios_base.h" 3
> typedef _Ios_Seekdir seekdir;
>
>
> static const seekdir beg = _S_beg;
>
>
> static const seekdir cur = _S_cur;
>
>
> static const seekdir end = _S_end;
># 489 "/usr/include/c++/8/bits/ios_base.h" 3
> enum event
> {
> erase_event,
> imbue_event,
> copyfmt_event
> };
># 506 "/usr/include/c++/8/bits/ios_base.h" 3
> typedef void (*event_callback) (event __e, ios_base& __b, int __i);
># 518 "/usr/include/c++/8/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();
>
> private:
> static _Atomic_word _S_refcount;
> static bool _S_synced_with_stdio;
> };
>
>
>
>
>
>
> fmtflags
> flags() const
> { return _M_flags; }
># 631 "/usr/include/c++/8/bits/ios_base.h" 3
> fmtflags
> flags(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags = __fmtfl;
> return __old;
> }
># 647 "/usr/include/c++/8/bits/ios_base.h" 3
> fmtflags
> setf(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags |= __fmtfl;
> return __old;
> }
># 664 "/usr/include/c++/8/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; }
># 690 "/usr/include/c++/8/bits/ios_base.h" 3
> streamsize
> precision() const
> { return _M_precision; }
>
>
>
>
>
>
> streamsize
> precision(streamsize __prec)
> {
> streamsize __old = _M_precision;
> _M_precision = __prec;
> return __old;
> }
>
>
>
>
>
>
>
> streamsize
> width() const
> { return _M_width; }
>
>
>
>
>
>
> streamsize
> width(streamsize __wide)
> {
> streamsize __old = _M_width;
> _M_width = __wide;
> return __old;
> }
># 741 "/usr/include/c++/8/bits/ios_base.h" 3
> static bool
> sync_with_stdio(bool __sync = true);
># 753 "/usr/include/c++/8/bits/ios_base.h" 3
> locale
> imbue(const locale& __loc) throw();
># 764 "/usr/include/c++/8/bits/ios_base.h" 3
> locale
> getloc() const
> { return _M_ios_locale; }
># 775 "/usr/include/c++/8/bits/ios_base.h" 3
> const locale&
> _M_getloc() const
> { return _M_ios_locale; }
># 794 "/usr/include/c++/8/bits/ios_base.h" 3
> static int
> xalloc() throw();
># 810 "/usr/include/c++/8/bits/ios_base.h" 3
> long&
> iword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, true);
> return __word._M_iword;
> }
># 831 "/usr/include/c++/8/bits/ios_base.h" 3
> void*&
> pword(int __ix)
> {
> _Words& __word = (__ix < _M_word_size)
> ? _M_word[__ix] : _M_grow_words(__ix, false);
> return __word._M_pword;
> }
># 848 "/usr/include/c++/8/bits/ios_base.h" 3
> virtual ~ios_base();
>
> protected:
> ios_base() throw ();
># 862 "/usr/include/c++/8/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;
> }
>
>
>
>}
># 43 "/usr/include/c++/8/ios" 2 3
># 1 "/usr/include/c++/8/streambuf" 1 3
># 36 "/usr/include/c++/8/streambuf" 3
> 
># 37 "/usr/include/c++/8/streambuf" 3
># 45 "/usr/include/c++/8/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&);
># 121 "/usr/include/c++/8/streambuf" 3
> template<typename _CharT, typename _Traits>
> class basic_streambuf
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
>
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
>
>
> friend class basic_ios<char_type, traits_type>;
> friend class basic_istream<char_type, traits_type>;
> friend class basic_ostream<char_type, traits_type>;
> friend class istreambuf_iterator<char_type, traits_type>;
> friend class ostreambuf_iterator<char_type, traits_type>;
>
> friend streamsize
> __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
>
> template<bool _IsMove, typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> _CharT2*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT2>,
> istreambuf_iterator<_CharT2>, _CharT2*);
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> const _CharT2&);
>
> template<typename _CharT2, typename _Distance>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> void>::__type
> advance(istreambuf_iterator<_CharT2>&, _Distance);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> getline(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
>
> protected:
>
>
>
>
>
>
>
> char_type* _M_in_beg;
> char_type* _M_in_cur;
> char_type* _M_in_end;
> char_type* _M_out_beg;
> char_type* _M_out_cur;
> char_type* _M_out_end;
>
>
> locale _M_buf_locale;
>
> public:
>
> virtual
> ~basic_streambuf()
> { }
># 215 "/usr/include/c++/8/streambuf" 3
> locale
> pubimbue(const locale& __loc)
> {
> locale __tmp(this->getloc());
> this->imbue(__loc);
> _M_buf_locale = __loc;
> return __tmp;
> }
># 232 "/usr/include/c++/8/streambuf" 3
> locale
> getloc() const
> { return _M_buf_locale; }
># 245 "/usr/include/c++/8/streambuf" 3
> basic_streambuf*
> pubsetbuf(char_type* __s, streamsize __n)
> { return this->setbuf(__s, __n); }
># 257 "/usr/include/c++/8/streambuf" 3
> pos_type
> pubseekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekoff(__off, __way, __mode); }
># 269 "/usr/include/c++/8/streambuf" 3
> pos_type
> pubseekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> { return this->seekpos(__sp, __mode); }
>
>
>
>
> int
> pubsync() { return this->sync(); }
># 290 "/usr/include/c++/8/streambuf" 3
> streamsize
> in_avail()
> {
> const streamsize __ret = this->egptr() - this->gptr();
> return __ret ? __ret : this->showmanyc();
> }
># 304 "/usr/include/c++/8/streambuf" 3
> int_type
> snextc()
> {
> int_type __ret = traits_type::eof();
> if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
> __ret), true))
> __ret = this->sgetc();
> return __ret;
> }
># 322 "/usr/include/c++/8/streambuf" 3
> int_type
> sbumpc()
> {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
> {
> __ret = traits_type::to_int_type(*this->gptr());
> this->gbump(1);
> }
> else
> __ret = this->uflow();
> return __ret;
> }
># 344 "/usr/include/c++/8/streambuf" 3
> int_type
> sgetc()
> {
> int_type __ret;
> if (__builtin_expect(this->gptr() < this->egptr(), true))
> __ret = traits_type::to_int_type(*this->gptr());
> else
> __ret = this->underflow();
> return __ret;
> }
># 363 "/usr/include/c++/8/streambuf" 3
> streamsize
> sgetn(char_type* __s, streamsize __n)
> { return this->xsgetn(__s, __n); }
># 378 "/usr/include/c++/8/streambuf" 3
> int_type
> sputbackc(char_type __c)
> {
> int_type __ret;
> const bool __testpos = this->eback() < this->gptr();
> if (__builtin_expect(!__testpos ||
> !traits_type::eq(__c, this->gptr()[-1]), false))
> __ret = this->pbackfail(traits_type::to_int_type(__c));
> else
> {
> this->gbump(-1);
> __ret = traits_type::to_int_type(*this->gptr());
> }
> return __ret;
> }
># 403 "/usr/include/c++/8/streambuf" 3
> int_type
> sungetc()
> {
> int_type __ret;
> if (__builtin_expect(this->eback() < this->gptr(), true))
> {
> this->gbump(-1);
> __ret = traits_type::to_int_type(*this->gptr());
> }
> else
> __ret = this->pbackfail();
> return __ret;
> }
># 430 "/usr/include/c++/8/streambuf" 3
> int_type
> sputc(char_type __c)
> {
> int_type __ret;
> if (__builtin_expect(this->pptr() < this->epptr(), true))
> {
> *this->pptr() = __c;
> this->pbump(1);
> __ret = traits_type::to_int_type(__c);
> }
> else
> __ret = this->overflow(traits_type::to_int_type(__c));
> return __ret;
> }
># 456 "/usr/include/c++/8/streambuf" 3
> streamsize
> sputn(const char_type* __s, streamsize __n)
> { return this->xsputn(__s, __n); }
>
> protected:
># 470 "/usr/include/c++/8/streambuf" 3
> basic_streambuf()
> : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
> _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
> _M_buf_locale(locale())
> { }
># 488 "/usr/include/c++/8/streambuf" 3
> char_type*
> eback() const { return _M_in_beg; }
>
> char_type*
> gptr() const { return _M_in_cur; }
>
> char_type*
> egptr() const { return _M_in_end; }
># 504 "/usr/include/c++/8/streambuf" 3
> void
> gbump(int __n) { _M_in_cur += __n; }
># 515 "/usr/include/c++/8/streambuf" 3
> void
> setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
> {
> _M_in_beg = __gbeg;
> _M_in_cur = __gnext;
> _M_in_end = __gend;
> }
># 535 "/usr/include/c++/8/streambuf" 3
> char_type*
> pbase() const { return _M_out_beg; }
>
> char_type*
> pptr() const { return _M_out_cur; }
>
> char_type*
> epptr() const { return _M_out_end; }
># 551 "/usr/include/c++/8/streambuf" 3
> void
> pbump(int __n) { _M_out_cur += __n; }
># 561 "/usr/include/c++/8/streambuf" 3
> void
> setp(char_type* __pbeg, char_type* __pend)
> {
> _M_out_beg = _M_out_cur = __pbeg;
> _M_out_end = __pend;
> }
># 582 "/usr/include/c++/8/streambuf" 3
> virtual void
> imbue(const locale& __loc __attribute__ ((__unused__)))
> { }
># 597 "/usr/include/c++/8/streambuf" 3
> virtual basic_streambuf<char_type,_Traits>*
> setbuf(char_type*, streamsize)
> { return this; }
># 608 "/usr/include/c++/8/streambuf" 3
> virtual pos_type
> seekoff(off_type, ios_base::seekdir,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 620 "/usr/include/c++/8/streambuf" 3
> virtual pos_type
> seekpos(pos_type,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 633 "/usr/include/c++/8/streambuf" 3
> virtual int
> sync() { return 0; }
># 655 "/usr/include/c++/8/streambuf" 3
> virtual streamsize
> showmanyc() { return 0; }
># 671 "/usr/include/c++/8/streambuf" 3
> virtual streamsize
> xsgetn(char_type* __s, streamsize __n);
># 693 "/usr/include/c++/8/streambuf" 3
> virtual int_type
> underflow()
> { return traits_type::eof(); }
># 706 "/usr/include/c++/8/streambuf" 3
> virtual int_type
> uflow()
> {
> int_type __ret = traits_type::eof();
> const bool __testeof = traits_type::eq_int_type(this->underflow(),
> __ret);
> if (!__testeof)
> {
> __ret = traits_type::to_int_type(*this->gptr());
> this->gbump(1);
> }
> return __ret;
> }
># 730 "/usr/include/c++/8/streambuf" 3
> virtual int_type
> pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
> { return traits_type::eof(); }
># 748 "/usr/include/c++/8/streambuf" 3
> virtual streamsize
> xsputn(const char_type* __s, streamsize __n);
># 774 "/usr/include/c++/8/streambuf" 3
> virtual int_type
> overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
> { return traits_type::eof(); }
># 803 "/usr/include/c++/8/streambuf" 3
> void
> __safe_gbump(streamsize __n) { _M_in_cur += __n; }
>
> void
> __safe_pbump(streamsize __n) { _M_out_cur += __n; }
>
>
>
>
> protected:
>
> basic_streambuf(const basic_streambuf&);
>
> basic_streambuf&
> operator=(const basic_streambuf&);
>
>
> void
> swap(basic_streambuf& __sb)
> {
> std::swap(_M_in_beg, __sb._M_in_beg);
> std::swap(_M_in_cur, __sb._M_in_cur);
> std::swap(_M_in_end, __sb._M_in_end);
> std::swap(_M_out_beg, __sb._M_out_beg);
> std::swap(_M_out_cur, __sb._M_out_cur);
> std::swap(_M_out_end, __sb._M_out_end);
> std::swap(_M_buf_locale, __sb._M_buf_locale);
> }
>
> };
>
>
> template<typename _CharT, typename _Traits>
> std::basic_streambuf<_CharT, _Traits>::
> basic_streambuf(const basic_streambuf&) = default;
>
> template<typename _CharT, typename _Traits>
> std::basic_streambuf<_CharT, _Traits>&
> std::basic_streambuf<_CharT, _Traits>::
> operator=(const basic_streambuf&) = default;
>
>
>
> template<>
> streamsize
> __copy_streambufs_eof(basic_streambuf<char>* __sbin,
> basic_streambuf<char>* __sbout, bool& __ineof);
>
> template<>
> streamsize
> __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
> basic_streambuf<wchar_t>* __sbout, bool& __ineof);
>
>
>
>
>
>}
>
># 1 "/usr/include/c++/8/bits/streambuf.tcc" 1 3
># 37 "/usr/include/c++/8/bits/streambuf.tcc" 3
> 
># 38 "/usr/include/c++/8/bits/streambuf.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsgetn(char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->egptr() - this->gptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(__s, this->gptr(), __len);
> __ret += __len;
> __s += __len;
> this->__safe_gbump(__len);
> }
>
> if (__ret < __n)
> {
> const int_type __c = this->uflow();
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> traits_type::assign(*__s++, traits_type::to_char_type(__c));
> ++__ret;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsputn(const char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->epptr() - this->pptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(this->pptr(), __s, __len);
> __ret += __len;
> __s += __len;
> this->__safe_pbump(__len);
> }
>
> if (__ret < __n)
> {
> int_type __c = this->overflow(traits_type::to_int_type(*__s));
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> ++__ret;
> ++__s;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout,
> bool& __ineof)
> {
> streamsize __ret = 0;
> __ineof = true;
> typename _Traits::int_type __c = __sbin->sgetc();
> while (!_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __c = __sbout->sputc(_Traits::to_char_type(__c));
> if (_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __ineof = false;
> break;
> }
> ++__ret;
> __c = __sbin->snextc();
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> inline streamsize
> __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout)
> {
> bool __ineof;
> return __copy_streambufs_eof(__sbin, __sbout, __ineof);
> }
>
>
>
>
> extern template class basic_streambuf<char>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<char>*,
> basic_streambuf<char>*);
> extern template
> streamsize
> __copy_streambufs_eof(basic_streambuf<char>*,
> basic_streambuf<char>*, bool&);
>
>
> extern template class basic_streambuf<wchar_t>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<wchar_t>*,
> basic_streambuf<wchar_t>*);
> extern template
> streamsize
> __copy_streambufs_eof(basic_streambuf<wchar_t>*,
> basic_streambuf<wchar_t>*, bool&);
>
>
>
>
>}
># 863 "/usr/include/c++/8/streambuf" 2 3
># 44 "/usr/include/c++/8/ios" 2 3
># 1 "/usr/include/c++/8/bits/basic_ios.h" 1 3
># 33 "/usr/include/c++/8/bits/basic_ios.h" 3
> 
># 34 "/usr/include/c++/8/bits/basic_ios.h" 3
>
>
>
># 1 "/usr/include/c++/8/bits/locale_facets.h" 1 3
># 37 "/usr/include/c++/8/bits/locale_facets.h" 3
> 
># 38 "/usr/include/c++/8/bits/locale_facets.h" 3
>
># 1 "/usr/include/c++/8/cwctype" 1 3
># 39 "/usr/include/c++/8/cwctype" 3
> 
># 40 "/usr/include/c++/8/cwctype" 3
># 50 "/usr/include/c++/8/cwctype" 3
># 1 "/usr/include/wctype.h" 1 3 4
># 38 "/usr/include/wctype.h" 3 4
># 1 "/usr/include/bits/wctype-wchar.h" 1 3 4
># 38 "/usr/include/bits/wctype-wchar.h" 3 4
>typedef unsigned long int wctype_t;
># 56 "/usr/include/bits/wctype-wchar.h" 3 4
>enum
>{
> __ISwupper = 0,
> __ISwlower = 1,
> __ISwalpha = 2,
> __ISwdigit = 3,
> __ISwxdigit = 4,
> __ISwspace = 5,
> __ISwprint = 6,
> __ISwgraph = 7,
> __ISwblank = 8,
> __ISwcntrl = 9,
> __ISwpunct = 10,
> __ISwalnum = 11,
>
> _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
> _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
> _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
> _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
> _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
> _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
> _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
> _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
> _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
> _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
> _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
> _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
>};
>
>
>
>extern "C" {
>
>
>
>
>
>
>
>extern int iswalnum (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswalpha (wint_t __wc) throw ();
>
>
>extern int iswcntrl (wint_t __wc) throw ();
>
>
>
>extern int iswdigit (wint_t __wc) throw ();
>
>
>
>extern int iswgraph (wint_t __wc) throw ();
>
>
>
>
>extern int iswlower (wint_t __wc) throw ();
>
>
>extern int iswprint (wint_t __wc) throw ();
>
>
>
>
>extern int iswpunct (wint_t __wc) throw ();
>
>
>
>
>extern int iswspace (wint_t __wc) throw ();
>
>
>
>
>extern int iswupper (wint_t __wc) throw ();
>
>
>
>
>extern int iswxdigit (wint_t __wc) throw ();
>
>
>
>
>
>extern int iswblank (wint_t __wc) throw ();
># 155 "/usr/include/bits/wctype-wchar.h" 3 4
>extern wctype_t wctype (const char *__property) throw ();
>
>
>
>extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
>
>
>
>
>
>
>extern wint_t towlower (wint_t __wc) throw ();
>
>
>extern wint_t towupper (wint_t __wc) throw ();
>
>}
># 39 "/usr/include/wctype.h" 2 3 4
>
>
>
>
>
>extern "C" {
>
>
>
>typedef const __int32_t *wctrans_t;
>
>
>
>extern wctrans_t wctrans (const char *__property) throw ();
>
>
>extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
>
>
>
>
>
>
>
>extern int iswalnum_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>
>extern int iswalpha_l (wint_t __wc, locale_t __locale) throw ();
>
>
>extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>extern int iswdigit_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>extern int iswgraph_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>extern int iswlower_l (wint_t __wc, locale_t __locale) throw ();
>
>
>extern int iswprint_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>extern int iswpunct_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>extern int iswspace_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>extern int iswupper_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>
>extern int iswblank_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>extern wctype_t wctype_l (const char *__property, locale_t __locale)
> throw ();
>
>
>
>extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
> throw ();
>
>
>
>
>
>
>extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw ();
>
>
>extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw ();
>
>
>
>extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
> throw ();
>
>
>extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
> locale_t __locale) throw ();
>
>
>
>}
># 51 "/usr/include/c++/8/cwctype" 2 3
># 80 "/usr/include/c++/8/cwctype" 3
>namespace std
>{
> using ::wctrans_t;
> using ::wctype_t;
> using ::wint_t;
>
> using ::iswalnum;
> using ::iswalpha;
>
> using ::iswblank;
>
> using ::iswcntrl;
> using ::iswctype;
> using ::iswdigit;
> using ::iswgraph;
> using ::iswlower;
> using ::iswprint;
> using ::iswpunct;
> using ::iswspace;
> using ::iswupper;
> using ::iswxdigit;
> using ::towctrans;
> using ::towlower;
> using ::towupper;
> using ::wctrans;
> using ::wctype;
>}
># 40 "/usr/include/c++/8/bits/locale_facets.h" 2 3
># 1 "/usr/include/c++/8/cctype" 1 3
># 39 "/usr/include/c++/8/cctype" 3
> 
># 40 "/usr/include/c++/8/cctype" 3
># 41 "/usr/include/c++/8/bits/locale_facets.h" 2 3
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h" 1 3
># 36 "/usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> struct ctype_base
> {
>
> typedef const int* __to_type;
>
>
>
> typedef unsigned short mask;
> static const mask upper = _ISupper;
> static const mask lower = _ISlower;
> static const mask alpha = _ISalpha;
> static const mask digit = _ISdigit;
> static const mask xdigit = _ISxdigit;
> static const mask space = _ISspace;
> static const mask print = _ISprint;
> static const mask graph = _ISalpha | _ISdigit | _ISpunct;
> static const mask cntrl = _IScntrl;
> static const mask punct = _ISpunct;
> static const mask alnum = _ISalpha | _ISdigit;
>
> static const mask blank = _ISblank;
>
> };
>
>
>}
># 42 "/usr/include/c++/8/bits/locale_facets.h" 2 3
>
>
>
>
>
>
># 1 "/usr/include/c++/8/bits/streambuf_iterator.h" 1 3
># 33 "/usr/include/c++/8/bits/streambuf_iterator.h" 3
> 
># 34 "/usr/include/c++/8/bits/streambuf_iterator.h" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 49 "/usr/include/c++/8/bits/streambuf_iterator.h" 3
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator
> : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
> _CharT*,
>
>
> _CharT>
>
>
>
> {
> public:
>
>
>
> 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>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> const _CharT2&);
>
> template<typename _CharT2, typename _Distance>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> void>::__type
> advance(istreambuf_iterator<_CharT2>&, _Distance);
>
> private:
>
>
>
>
>
>
>
> mutable streambuf_type* _M_sbuf;
> int_type _M_c;
>
> public:
>
> constexpr istreambuf_iterator() noexcept
> : _M_sbuf(0), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
>
> ~istreambuf_iterator() = default;
>
>
>
> istreambuf_iterator(istream_type& __s) noexcept
> : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(streambuf_type* __s) noexcept
> : _M_sbuf(__s), _M_c(traits_type::eof()) { }
>
>
>
>
> char_type
> operator*() const
> {
> int_type __c = _M_get();
># 139 "/usr/include/c++/8/bits/streambuf_iterator.h" 3
> return traits_type::to_char_type(__c);
> }
>
>
> istreambuf_iterator&
> operator++()
> {
>
>
>
> ;
>
> _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> return *this;
> }
>
>
> istreambuf_iterator
> operator++(int)
> {
>
>
>
> ;
>
> istreambuf_iterator __old = *this;
> __old._M_c = _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> return __old;
> }
>
>
>
>
>
> bool
> equal(const istreambuf_iterator& __b) const
> { return _M_at_eof() == __b._M_at_eof(); }
>
> private:
> int_type
> _M_get() const
> {
> int_type __ret = _M_c;
> if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
> _M_sbuf = 0;
> return __ret;
> }
>
> bool
> _M_at_eof() const
> { return _S_is_eof(_M_get()); }
>
> static bool
> _S_is_eof(int_type __c)
> {
> const int_type __eof = traits_type::eof();
> return traits_type::eq_int_type(__c, __eof);
> }
> };
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return __a.equal(__b); }
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return !__a.equal(__b); }
>
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> ostreambuf_iterator<_CharT2> >::__type
> copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> ostreambuf_iterator<_CharT2>);
>
> private:
> streambuf_type* _M_sbuf;
> bool _M_failed;
>
> public:
>
> ostreambuf_iterator(ostream_type& __s) noexcept
> : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator(streambuf_type* __s) noexcept
> : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator&
> operator=(_CharT __c)
> {
> if (!_M_failed &&
> _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
> _M_failed = true;
> return *this;
> }
>
>
> ostreambuf_iterator&
> operator*()
> { return *this; }
>
>
> ostreambuf_iterator&
> operator++(int)
> { return *this; }
>
>
> ostreambuf_iterator&
> operator++()
> { return *this; }
>
>
> bool
> failed() const noexcept
> { return _M_failed; }
>
> ostreambuf_iterator&
> _M_put(const _CharT* __ws, streamsize __len)
> {
> if (__builtin_expect(!_M_failed, true)
> && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
> false))
> _M_failed = true;
> return *this;
> }
> };
>
>
> template<typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> copy(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last,
> ostreambuf_iterator<_CharT> __result)
> {
> if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
> {
> bool __ineof;
> __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
> if (!__ineof)
> __result._M_failed = true;
> }
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> __copy_move_a2(_CharT* __first, _CharT* __last,
> ostreambuf_iterator<_CharT> __result)
> {
> const streamsize __num = __last - __first;
> if (__num > 0)
> __result._M_put(__first, __num);
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> __copy_move_a2(const _CharT* __first, const _CharT* __last,
> ostreambuf_iterator<_CharT> __result)
> {
> const streamsize __num = __last - __first;
> if (__num > 0)
> __result._M_put(__first, __num);
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> _CharT*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last, _CharT* __result)
> {
> typedef istreambuf_iterator<_CharT> __is_iterator_type;
> typedef typename __is_iterator_type::traits_type traits_type;
> typedef typename __is_iterator_type::streambuf_type streambuf_type;
> typedef typename traits_type::int_type int_type;
>
> if (__first._M_sbuf && !__last._M_sbuf)
> {
> streambuf_type* __sb = __first._M_sbuf;
> int_type __c = __sb->sgetc();
> while (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> const streamsize __n = __sb->egptr() - __sb->gptr();
> if (__n > 1)
> {
> traits_type::copy(__result, __sb->gptr(), __n);
> __sb->__safe_gbump(__n);
> __result += __n;
> __c = __sb->underflow();
> }
> else
> {
> *__result++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> }
> }
> }
> return __result;
> }
>
> template<typename _CharT>
> typename __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;
>
> ;
> 
>
> ;
>
> typedef istreambuf_iterator<_CharT> __is_iterator_type;
> typedef typename __is_iterator_type::traits_type traits_type;
> typedef typename __is_iterator_type::streambuf_type streambuf_type;
> typedef typename traits_type::int_type int_type;
> const int_type __eof = traits_type::eof();
>
> streambuf_type* __sb = __i._M_sbuf;
> while (__n > 0)
> {
> streamsize __size = __sb->egptr() - __sb->gptr();
> if (__size > __n)
> {
> __sb->__safe_gbump(__n);
> break;
> }
>
> __sb->__safe_gbump(__size);
> __n -= __size;
> if (traits_type::eq_int_type(__sb->underflow(), __eof))
> {
> 
>
> ;
> break;
> }
> }
>
> __i._M_c = __eof;
> }
>
>
>
>
>}
># 49 "/usr/include/c++/8/bits/locale_facets.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 71 "/usr/include/c++/8/bits/locale_facets.h" 3
> template<typename _Tp>
> void
> __convert_to_v(const char*, _Tp&, ios_base::iostate&,
> const __c_locale&) throw();
>
>
> template<>
> void
> __convert_to_v(const char*, float&, ios_base::iostate&,
> const __c_locale&) throw();
>
> template<>
> void
> __convert_to_v(const char*, double&, ios_base::iostate&,
> const __c_locale&) throw();
>
> template<>
> void
> __convert_to_v(const char*, long double&, ios_base::iostate&,
> const __c_locale&) throw();
>
>
>
> template<typename _CharT, typename _Traits>
> struct __pad
> {
> static void
> _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
> const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
> };
>
>
>
>
>
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last);
>
>
>
>
> template<typename _CharT>
> inline
> ostreambuf_iterator<_CharT>
> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
> {
> __s._M_put(__ws, __len);
> return __s;
> }
>
>
> template<typename _CharT, typename _OutIter>
> inline
> _OutIter
> __write(_OutIter __s, const _CharT* __ws, int __len)
> {
> for (int __j = 0; __j < __len; __j++, ++__s)
> *__s = __ws[__j];
> return __s;
> }
># 149 "/usr/include/c++/8/bits/locale_facets.h" 3
> template<typename _CharT>
> class __ctype_abstract_base : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef _CharT char_type;
># 168 "/usr/include/c++/8/bits/locale_facets.h" 3
> bool
> is(mask __m, char_type __c) const
> { return this->do_is(__m, __c); }
># 185 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> is(const char_type *__lo, const char_type *__hi, mask *__vec) const
> { return this->do_is(__lo, __hi, __vec); }
># 201 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
> { return this->do_scan_is(__m, __lo, __hi); }
># 217 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
> { return this->do_scan_not(__m, __lo, __hi); }
># 231 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 246 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 260 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 275 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 292 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> { return this->do_widen(__c); }
># 311 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> { return this->do_widen(__lo, __hi, __to); }
># 330 "/usr/include/c++/8/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return this->do_narrow(__c, __dfault); }
># 352 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const
> { return this->do_narrow(__lo, __hi, __dfault, __to); }
>
> protected:
> explicit
> __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
>
> virtual
> ~__ctype_abstract_base() { }
># 377 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const = 0;
># 396 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi,
> mask* __vec) const = 0;
># 415 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 434 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 452 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const = 0;
># 469 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const = 0;
># 485 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const = 0;
># 502 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const = 0;
># 521 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const = 0;
># 542 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
># 563 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const = 0;
># 588 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const = 0;
> };
># 611 "/usr/include/c++/8/bits/locale_facets.h" 3
> template<typename _CharT>
> class ctype : public __ctype_abstract_base<_CharT>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename __ctype_abstract_base<_CharT>::mask mask;
>
>
> static locale::id id;
>
> explicit
> ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
>
> protected:
> virtual
> ~ctype();
>
> virtual bool
> do_is(mask __m, char_type __c) const;
>
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
>
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
>
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
>
> virtual char_type
> do_toupper(char_type __c) const;
>
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
>
> virtual char_type
> do_tolower(char_type __c) const;
>
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
>
> virtual char_type
> do_widen(char __c) const;
>
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
>
> virtual char
> do_narrow(char_type, char __dfault) const;
>
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const;
> };
>
> template<typename _CharT>
> locale::id ctype<_CharT>::id;
># 680 "/usr/include/c++/8/bits/locale_facets.h" 3
> template<>
> class ctype<char> : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef char char_type;
>
> protected:
>
> __c_locale _M_c_locale_ctype;
> bool _M_del;
> __to_type _M_toupper;
> __to_type _M_tolower;
> const mask* _M_table;
> mutable char _M_widen_ok;
> mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow_ok;
>
>
> public:
>
> static locale::id id;
>
> static const size_t table_size = 1 + static_cast<unsigned char>(-1);
># 717 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
># 730 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
> size_t __refs = 0);
># 743 "/usr/include/c++/8/bits/locale_facets.h" 3
> inline bool
> is(mask __m, char __c) const;
># 758 "/usr/include/c++/8/bits/locale_facets.h" 3
> inline const char*
> is(const char* __lo, const char* __hi, mask* __vec) const;
># 772 "/usr/include/c++/8/bits/locale_facets.h" 3
> inline const char*
> scan_is(mask __m, const char* __lo, const char* __hi) const;
># 786 "/usr/include/c++/8/bits/locale_facets.h" 3
> inline const char*
> scan_not(mask __m, const char* __lo, const char* __hi) const;
># 801 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 818 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 834 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 851 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 871 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> {
> if (_M_widen_ok)
> return _M_widen[static_cast<unsigned char>(__c)];
> this->_M_widen_init();
> return this->do_widen(__c);
> }
># 898 "/usr/include/c++/8/bits/locale_facets.h" 3
> const char*
> widen(const char* __lo, const char* __hi, char_type* __to) const
> {
> if (_M_widen_ok == 1)
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
> if (!_M_widen_ok)
> _M_widen_init();
> return this->do_widen(__lo, __hi, __to);
> }
># 929 "/usr/include/c++/8/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;
> }
># 962 "/usr/include/c++/8/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))
> {
> __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();
># 1011 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const;
># 1028 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1044 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const;
># 1061 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1081 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const
> { return __c; }
># 1104 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
># 1130 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
> { return __c; }
># 1156 "/usr/include/c++/8/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
> {
> __builtin_memcpy(__to, __lo, __hi - __lo);
> return __hi;
> }
>
> private:
> void _M_narrow_init() const;
> void _M_widen_init() const;
> };
># 1181 "/usr/include/c++/8/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;
># 1214 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> ctype(size_t __refs = 0);
># 1225 "/usr/include/c++/8/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();
># 1249 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const;
># 1268 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
># 1286 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
># 1304 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
># 1321 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const;
># 1338 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1354 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const;
># 1371 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1391 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const;
># 1413 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const;
># 1436 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const;
># 1462 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual const char_type*
> do_narrow(const char_type* __lo, const char_type* __hi,
> char __dfault, char* __to) const;
>
>
> void
> _M_initialize_ctype() throw();
> };
>
>
>
> template<typename _CharT>
> class ctype_byname : public ctype<_CharT>
> {
> public:
> typedef typename ctype<_CharT>::mask mask;
>
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
>
> explicit
> ctype_byname(const string& __s, size_t __refs = 0)
> : ctype_byname(__s.c_str(), __refs) { }
>
>
> protected:
> virtual
> ~ctype_byname() { }
> };
>
>
> template<>
> class ctype_byname<char> : public ctype<char>
> {
> public:
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
>
> explicit
> ctype_byname(const string& __s, size_t __refs = 0);
>
>
> protected:
> virtual
> ~ctype_byname();
> };
>
>
> template<>
> class ctype_byname<wchar_t> : public ctype<wchar_t>
> {
> public:
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
>
> explicit
> ctype_byname(const string& __s, size_t __refs = 0);
>
>
> protected:
> virtual
> ~ctype_byname();
> };
>
>
>
>}
>
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
># 37 "/usr/include/c++/8/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;
> }
>
>
>}
># 1535 "/usr/include/c++/8/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 {
># 1665 "/usr/include/c++/8/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(); }
># 1703 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> numpunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_numpunct(); }
># 1717 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> numpunct(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_data(0)
> { _M_initialize_numpunct(__cloc); }
># 1731 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 1744 "/usr/include/c++/8/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 1775 "/usr/include/c++/8/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 1788 "/usr/include/c++/8/bits/locale_facets.h" 3
> string_type
> truename() const
> { return this->do_truename(); }
># 1801 "/usr/include/c++/8/bits/locale_facets.h" 3
> string_type
> falsename() const
> { return this->do_falsename(); }
>
> protected:
>
> virtual
> ~numpunct();
># 1818 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 1830 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 1843 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 1856 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual string_type
> do_truename() const
> { return _M_data->_M_truename; }
># 1869 "/usr/include/c++/8/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() { }
> };
>
>}
>
>
># 1947 "/usr/include/c++/8/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;
># 1968 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> num_get(size_t __refs = 0) : facet(__refs) { }
># 1994 "/usr/include/c++/8/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); }
># 2031 "/usr/include/c++/8/bits/locale_facets.h" 3
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned short& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned int& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
>
> iter_type
> get(iter_type __in, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long long& __v) const
> { return this->do_get(__in, __end, __io, __err, __v); }
># 2091 "/usr/include/c++/8/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); }
># 2134 "/usr/include/c++/8/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;
> }
># 2207 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned short& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned int& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
> virtual iter_type
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, unsigned long long& __v) const
> { return _M_extract_int(__beg, __end, __io, __err, __v); }
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
> double&) const;
>
>
>
>
>
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
> long double&) const;
>
>
> virtual iter_type
> do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
># 2270 "/usr/include/c++/8/bits/locale_facets.h" 3
> };
>
> template<typename _CharT, typename _InIter>
> locale::id num_get<_CharT, _InIter>::id;
># 2288 "/usr/include/c++/8/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;
># 2309 "/usr/include/c++/8/bits/locale_facets.h" 3
> explicit
> num_put(size_t __refs = 0) : facet(__refs) { }
># 2327 "/usr/include/c++/8/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); }
># 2369 "/usr/include/c++/8/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return this->do_put(__s, __io, __fill, __v); }
># 2432 "/usr/include/c++/8/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); }
># 2457 "/usr/include/c++/8/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() { }
># 2505 "/usr/include/c++/8/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, double) const;
>
>
>
>
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, long double) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, const void*) const;
>
>
>
>
>
>
>
> };
>
> template <typename _CharT, typename _OutIter>
> locale::id num_put<_CharT, _OutIter>::id;
>
>
>
>
>
>
>
>
>
> template<typename _CharT>
> inline bool
> isspace(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
>
>
> template<typename _CharT>
> inline bool
> isprint(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
>
>
> template<typename _CharT>
> inline bool
> iscntrl(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
>
>
> template<typename _CharT>
> inline bool
> isupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
>
>
> template<typename _CharT>
> inline bool
> islower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalpha(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
>
>
> template<typename _CharT>
> inline bool
> isdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
>
>
> template<typename _CharT>
> inline bool
> ispunct(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
>
>
> template<typename _CharT>
> inline bool
> isxdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalnum(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
>
>
> template<typename _CharT>
> inline bool
> isgraph(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
>
>
>
> template<typename _CharT>
> inline bool
> isblank(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
>
>
>
> template<typename _CharT>
> inline _CharT
> toupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
>
>
> template<typename _CharT>
> inline _CharT
> tolower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
>
>
>}
>
># 1 "/usr/include/c++/8/bits/locale_facets.tcc" 1 3
># 33 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> 
># 34 "/usr/include/c++/8/bits/locale_facets.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _Facet>
> struct __use_cache
> {
> const _Facet*
> operator() (const locale& __loc) const;
> };
>
>
> template<typename _CharT>
> struct __use_cache<__numpunct_cache<_CharT> >
> {
> const __numpunct_cache<_CharT>*
> operator() (const locale& __loc) const
> {
> const size_t __i = numpunct<_CharT>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __numpunct_cache<_CharT>* __tmp = 0;
> try
> {
> __tmp = new __numpunct_cache<_CharT>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
> }
> };
>
> template<typename _CharT>
> void
> __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
> {
> const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
>
> char* __grouping = 0;
> _CharT* __truename = 0;
> _CharT* __falsename = 0;
> try
> {
> const string& __g = __np.grouping();
> _M_grouping_size = __g.size();
> __grouping = new char[_M_grouping_size];
> __g.copy(__grouping, _M_grouping_size);
> _M_use_grouping = (_M_grouping_size
> && static_cast<signed char>(__grouping[0]) > 0
> && (__grouping[0]
> != __gnu_cxx::__numeric_traits<char>::__max));
>
> const basic_string<_CharT>& __tn = __np.truename();
> _M_truename_size = __tn.size();
> __truename = new _CharT[_M_truename_size];
> __tn.copy(__truename, _M_truename_size);
>
> const basic_string<_CharT>& __fn = __np.falsename();
> _M_falsename_size = __fn.size();
> __falsename = new _CharT[_M_falsename_size];
> __fn.copy(__falsename, _M_falsename_size);
>
> _M_decimal_point = __np.decimal_point();
> _M_thousands_sep = __np.thousands_sep();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(__num_base::_S_atoms_out,
> __num_base::_S_atoms_out
> + __num_base::_S_oend, _M_atoms_out);
> __ct.widen(__num_base::_S_atoms_in,
> __num_base::_S_atoms_in
> + __num_base::_S_iend, _M_atoms_in);
>
> _M_grouping = __grouping;
> _M_truename = __truename;
> _M_falsename = __falsename;
> _M_allocated = true;
> }
> catch(...)
> {
> delete [] __grouping;
> delete [] __truename;
> delete [] __falsename;
> throw;
> }
> }
># 139 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> __attribute__ ((__pure__)) bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp) throw ();
>
>
>
> template<typename _CharT, typename _InIter>
> __attribute ((__abi_tag__ ("cxx11")))
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, string& __xtrc) const
> {
> typedef char_traits<_CharT> __traits_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> bool __testeof = __beg == __end;
>
>
> if (!__testeof)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> __xtrc += __plus ? '+' : '-';
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
> bool __found_mantissa = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero])
> {
> if (!__found_mantissa)
> {
> __xtrc += '0';
> __found_mantissa = true;
> }
> ++__sep_pos;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> break;
> }
>
>
> bool __found_dec = false;
> bool __found_sci = false;
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
> if (!__lc->_M_allocated)
>
> while (!__testeof)
> {
> const int __digit = _M_find(__lit_zero, 10, __c);
> if (__digit != -1)
> {
> __xtrc += '0' + __digit;
> __found_mantissa = true;
> }
> else if (__c == __lc->_M_decimal_point
> && !__found_dec && !__found_sci)
> {
> __xtrc += '.';
> __found_dec = true;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && !__found_sci && __found_mantissa)
> {
>
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if (__plus || __c == __lit[__num_base::_S_iminus])
> __xtrc += __plus ? '+' : '-';
> else
> continue;
> }
> else
> {
> __testeof = true;
> break;
> }
> }
> else
> break;
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
>
>
> __xtrc.clear();
> break;
> }
> }
> else
> break;
> }
> else if (__c == __lc->_M_decimal_point)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
>
> if (__found_grouping.size())
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += '.';
> __found_dec = true;
> }
> else
> break;
> }
> else
> {
> const char_type* __q =
> __traits_type::find(__lit_zero, 10, __c);
> if (__q)
> {
> __xtrc += '0' + (__q - __lit_zero);
> __found_mantissa = true;
> ++__sep_pos;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && !__found_sci && __found_mantissa)
> {
>
> if (__found_grouping.size() && !__found_dec)
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping
> && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> __xtrc += __plus ? '+' : '-';
> else
> continue;
> }
> else
> {
> __testeof = true;
> break;
> }
> }
> else
> break;
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> if (!__found_dec && !__found_sci)
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err = ios_base::failbit;
> }
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> template<typename _ValueT>
> __attribute ((__abi_tag__ ("cxx11")))
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, _ValueT& __v) const
> {
> typedef char_traits<_CharT> __traits_type;
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> const ios_base::fmtflags __basefield = __io.flags()
> & ios_base::basefield;
> const bool __oct = __basefield == ios_base::oct;
> int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
>
>
> bool __testeof = __beg == __end;
>
>
> bool __negative = false;
> if (!__testeof)
> {
> __c = *__beg;
> __negative = __c == __lit[__num_base::_S_iminus];
> if ((__negative || __c == __lit[__num_base::_S_iplus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
>
> bool __found_zero = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero]
> && (!__found_zero || __base == 10))
> {
> __found_zero = true;
> ++__sep_pos;
> if (__basefield == 0)
> __base = 8;
> if (__base == 8)
> __sep_pos = 0;
> }
> else if (__found_zero
> && (__c == __lit[__num_base::_S_ix]
> || __c == __lit[__num_base::_S_iX]))
> {
> if (__basefield == 0)
> __base = 16;
> if (__base == 16)
> {
> __found_zero = false;
> __sep_pos = 0;
> }
> else
> break;
> }
> else
> break;
>
> if (++__beg != __end)
> {
> __c = *__beg;
> if (!__found_zero)
> break;
> }
> else
> __testeof = true;
> }
>
>
>
> const size_t __len = (__base == 16 ? __num_base::_S_iend
> - __num_base::_S_izero : __base);
>
>
> typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> bool __testfail = false;
> bool __testoverflow = false;
> const __unsigned_type __max =
> (__negative && __num_traits::__is_signed)
> ? -static_cast<__unsigned_type>(__num_traits::__min)
> : __num_traits::__max;
> const __unsigned_type __smax = __max / __base;
> __unsigned_type __result = 0;
> int __digit = 0;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
> if (!__lc->_M_allocated)
>
> while (!__testeof)
> {
> __digit = _M_find(__lit_zero, __len, __c);
> if (__digit == -1)
> break;
>
> if (__result > __smax)
> __testoverflow = true;
> else
> {
> __result *= __base;
> __testoverflow |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
> __testfail = true;
> break;
> }
> }
> else if (__c == __lc->_M_decimal_point)
> break;
> else
> {
> const char_type* __q =
> __traits_type::find(__lit_zero, __len, __c);
> if (!__q)
> break;
>
> __digit = __q - __lit_zero;
> if (__digit > 15)
> __digit -= 6;
> if (__result > __smax)
> __testoverflow = true;
> else
> {
> __result *= __base;
> __testoverflow |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err = ios_base::failbit;
> }
>
>
>
> if ((!__sep_pos && !__found_zero && !__found_grouping.size())
> || __testfail)
> {
> __v = 0;
> __err = ios_base::failbit;
> }
> else if (__testoverflow)
> {
> if (__negative && __num_traits::__is_signed)
> __v = __num_traits::__min;
> else
> __v = __num_traits::__max;
> __err = ios_base::failbit;
> }
> else
> __v = __negative ? -__result : __result;
>
> if (__testeof)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, bool& __v) const
> {
> if (!(__io.flags() & ios_base::boolalpha))
> {
>
>
>
> long __l = -1;
> __beg = _M_extract_int(__beg, __end, __io, __err, __l);
> if (__l == 0 || __l == 1)
> __v = bool(__l);
> else
> {
>
>
> __v = true;
> __err = ios_base::failbit;
> if (__beg == __end)
> __err |= ios_base::eofbit;
> }
> }
> else
> {
>
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> bool __testf = true;
> bool __testt = true;
> bool __donef = __lc->_M_falsename_size == 0;
> bool __donet = __lc->_M_truename_size == 0;
> bool __testeof = false;
> size_t __n = 0;
> while (!__donef || !__donet)
> {
> if (__beg == __end)
> {
> __testeof = true;
> break;
> }
>
> const char_type __c = *__beg;
>
> if (!__donef)
> __testf = __c == __lc->_M_falsename[__n];
>
> if (!__testf && __donet)
> break;
>
> if (!__donet)
> __testt = __c == __lc->_M_truename[__n];
>
> if (!__testt && __donef)
> break;
>
> if (!__testt && !__testf)
> break;
>
> ++__n;
> ++__beg;
>
> __donef = !__testf || __n >= __lc->_M_falsename_size;
> __donet = !__testt || __n >= __lc->_M_truename_size;
> }
> if (__testf && __n == __lc->_M_falsename_size && __n)
> {
> __v = false;
> if (__testt && __n == __lc->_M_truename_size)
> __err = ios_base::failbit;
> else
> __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
> }
> else if (__testt && __n == __lc->_M_truename_size && __n)
> {
> __v = true;
> __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
> }
> else
> {
>
>
> __v = false;
> __err = ios_base::failbit;
> if (__testeof)
> __err |= ios_base::eofbit;
> }
> }
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, float& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
># 735 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, void*& __v) const
> {
>
> typedef ios_base::fmtflags fmtflags;
> const fmtflags __fmt = __io.flags();
> __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
>
> typedef __gnu_cxx::__conditional_type<(sizeof(void*)
> <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
> _UIntPtrType __ul;
> __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
>
>
> __io.flags(__fmt);
>
> __v = reinterpret_cast<void*>(__ul);
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
> _CharT* __new, const _CharT* __cs, int& __len) const
> {
>
>
> __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
> __cs, __w, __len);
> __len = static_cast<int>(__w);
> }
>
>
>
> template<typename _CharT, typename _ValueT>
> int
> __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
> ios_base::fmtflags __flags, bool __dec)
> {
> _CharT* __buf = __bufend;
> if (__builtin_expect(__dec, true))
> {
>
> do
> {
> *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
> __v /= 10;
> }
> while (__v != 0);
> }
> else if ((__flags & ios_base::basefield) == ios_base::oct)
> {
>
> do
> {
> *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
> __v >>= 3;
> }
> while (__v != 0);
> }
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> const int __case_offset = __uppercase ? __num_base::_S_oudigits
> : __num_base::_S_odigits;
> do
> {
> *--__buf = __lit[(__v & 0xf) + __case_offset];
> __v >>= 4;
> }
> while (__v != 0);
> }
> return __bufend - __buf;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
> ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
> {
> _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size, __cs, __cs + __len);
> __len = __p - __new;
> }
>
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _OutIter
> num_put<_CharT, _OutIter>::
> _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
> _ValueT __v) const
> {
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_out;
> const ios_base::fmtflags __flags = __io.flags();
>
>
> const int __ilen = 5 * sizeof(_ValueT);
> _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __ilen));
>
>
>
> const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
> const bool __dec = (__basefield != ios_base::oct
> && __basefield != ios_base::hex);
> const __unsigned_type __u = ((__v > 0 || !__dec)
> ? __unsigned_type(__v)
> : -__unsigned_type(__v));
> int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
> __cs += __ilen - __len;
>
>
> if (__lc->_M_use_grouping)
> {
>
>
> _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * (__len + 1)
> * 2));
> _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
> __cs = __cs2 + 2;
> }
>
>
> if (__builtin_expect(__dec, true))
> {
>
> if (__v >= 0)
> {
> if (bool(__flags & ios_base::showpos)
> && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
> *--__cs = __lit[__num_base::_S_oplus], ++__len;
> }
> else
> *--__cs = __lit[__num_base::_S_ominus], ++__len;
> }
> else if (bool(__flags & ios_base::showbase) && __v)
> {
> if (__basefield == ios_base::oct)
> *--__cs = __lit[__num_base::_S_odigits], ++__len;
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> *--__cs = __lit[__num_base::_S_ox + __uppercase];
>
> *--__cs = __lit[__num_base::_S_odigits];
> __len += 2;
> }
> }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __cs3, __cs, __len);
> __cs = __cs3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __cs, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_float(const char* __grouping, size_t __grouping_size,
> _CharT __sep, const _CharT* __p, _CharT* __new,
> _CharT* __cs, int& __len) const
> {
>
>
>
> const int __declen = __p ? __p - __cs : __len;
> _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size,
> __cs, __cs + __declen);
>
>
> int __newlen = __p2 - __new;
> if (__p)
> {
> char_traits<_CharT>::copy(__p2, __p, __len - __declen);
> __newlen += __len - __declen;
> }
> __len = __newlen;
> }
># 971 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _OutIter
> num_put<_CharT, _OutIter>::
> _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
> _ValueT __v) const
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
>
> const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
>
> const int __max_digits =
> __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
>
>
> int __len;
>
> char __fbuf[16];
> __num_base::_S_format_float(__io, __fbuf, __mod);
>
>
>
> const bool __use_prec =
> (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
>
>
>
> int __cs_size = __max_digits * 3;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> if (__use_prec)
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __prec, __v);
> else
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __v);
>
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> if (__use_prec)
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __prec, __v);
> else
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __v);
> }
># 1044 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __ctype.widen(__cs, __cs + __len, __ws);
>
>
> _CharT* __wp = 0;
> const char* __p = char_traits<char>::find(__cs, __len, '.');
> if (__p)
> {
> __wp = __ws + (__p - __cs);
> *__wp = __lc->_M_decimal_point;
> }
>
>
>
>
> if (__lc->_M_use_grouping
> && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
> && __cs[1] >= '0' && __cs[2] >= '0')))
> {
>
>
> _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len * 2));
>
> streamsize __off = 0;
> if (__cs[0] == '-' || __cs[0] == '+')
> {
> __off = 1;
> __ws2[0] = __ws[0];
> __len -= 1;
> }
>
> _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
> __lc->_M_thousands_sep, __wp, __ws2 + __off,
> __ws + __off, __len);
> __len += __off;
>
> __ws = __ws2;
> }
>
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __ws3, __ws, __len);
> __ws = __ws3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __ws, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> if ((__flags & ios_base::boolalpha) == 0)
> {
> const long __l = __v;
> __s = _M_insert_int(__s, __io, __fill, __l);
> }
> else
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> const _CharT* __name = __v ? __lc->_M_truename
> : __lc->_M_falsename;
> int __len = __v ? __lc->_M_truename_size
> : __lc->_M_falsename_size;
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> const streamsize __plen = __w - __len;
> _CharT* __ps
> = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __plen));
>
> char_traits<_CharT>::assign(__ps, __plen, __fill);
> __io.width(0);
>
> if ((__flags & ios_base::adjustfield) == ios_base::left)
> {
> __s = std::__write(__s, __name, __len);
> __s = std::__write(__s, __ps, __plen);
> }
> else
> {
> __s = std::__write(__s, __ps, __plen);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
> __io.width(0);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
> { return _M_insert_float(__s, __io, __fill, char(), __v); }
># 1169 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long double __v) const
> { return _M_insert_float(__s, __io, __fill, 'L', __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> const void* __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> const ios_base::fmtflags __fmt = ~(ios_base::basefield
> | ios_base::uppercase);
> __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
>
> typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
> <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
> __s = _M_insert_int(__s, __io, __fill,
> reinterpret_cast<_UIntPtrType>(__v));
> __io.flags(__flags);
> return __s;
> }
>
>
># 1206 "/usr/include/c++/8/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _Traits>
> void
> __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
> _CharT* __news, const _CharT* __olds,
> streamsize __newlen, streamsize __oldlen)
> {
> const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
> const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
>
>
> if (__adjust == ios_base::left)
> {
> _Traits::copy(__news, __olds, __oldlen);
> _Traits::assign(__news + __oldlen, __plen, __fill);
> return;
> }
>
> size_t __mod = 0;
> if (__adjust == ios_base::internal)
> {
>
>
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> if (__ctype.widen('-') == __olds[0]
> || __ctype.widen('+') == __olds[0])
> {
> __news[0] = __olds[0];
> __mod = 1;
> ++__news;
> }
> else if (__ctype.widen('0') == __olds[0]
> && __oldlen > 1
> && (__ctype.widen('x') == __olds[1]
> || __ctype.widen('X') == __olds[1]))
> {
> __news[0] = __olds[0];
> __news[1] = __olds[1];
> __mod = 2;
> __news += 2;
> }
>
> }
> _Traits::assign(__news, __plen, __fill);
> _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
> }
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last)
> {
> size_t __idx = 0;
> size_t __ctr = 0;
>
> while (__last - __first > __gbeg[__idx]
> && static_cast<signed char>(__gbeg[__idx]) > 0
> && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
> {
> __last -= __gbeg[__idx];
> __idx < __gsize - 1 ? ++__idx : ++__ctr;
> }
>
> while (__first != __last)
> *__s++ = *__first++;
>
> while (__ctr--)
> {
> *__s++ = __sep;
> for (char __i = __gbeg[__idx]; __i > 0; --__i)
> *__s++ = *__first++;
> }
>
> while (__idx--)
> {
> *__s++ = __sep;
> for (char __i = __gbeg[__idx]; __i > 0; --__i)
> *__s++ = *__first++;
> }
>
> return __s;
> }
>
>
>
>
> extern template class __cxx11:: numpunct<char>;
> extern template class __cxx11:: numpunct_byname<char>;
> extern template class num_get<char>;
> extern template class num_put<char>;
> extern template class ctype_byname<char>;
>
> extern template
> const ctype<char>&
> use_facet<ctype<char> >(const locale&);
>
> extern template
> const numpunct<char>&
> use_facet<numpunct<char> >(const locale&);
>
> extern template
> const num_put<char>&
> use_facet<num_put<char> >(const locale&);
>
> extern template
> const num_get<char>&
> use_facet<num_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<char> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<char> >(const locale&);
>
>
> extern template class __cxx11:: numpunct<wchar_t>;
> extern template class __cxx11:: numpunct_byname<wchar_t>;
> extern template class num_get<wchar_t>;
> extern template class num_put<wchar_t>;
> extern template class ctype_byname<wchar_t>;
>
> extern template
> const ctype<wchar_t>&
> use_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> const numpunct<wchar_t>&
> use_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> const num_put<wchar_t>&
> use_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> const num_get<wchar_t>&
> use_facet<num_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<wchar_t> >(const locale&);
>
>
>
>
>}
># 2652 "/usr/include/c++/8/bits/locale_facets.h" 2 3
># 38 "/usr/include/c++/8/bits/basic_ios.h" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Facet>
> inline const _Facet&
> __check_facet(const _Facet* __f)
> {
> if (!__f)
> __throw_bad_cast();
> return *__f;
> }
># 66 "/usr/include/c++/8/bits/basic_ios.h" 3
> template<typename _CharT, typename _Traits>
> class basic_ios : public ios_base
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
>
>
>
>
> typedef ctype<_CharT> __ctype_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
>
>
>
> protected:
> basic_ostream<_CharT, _Traits>* _M_tie;
> mutable char_type _M_fill;
> mutable bool _M_fill_init;
> basic_streambuf<_CharT, _Traits>* _M_streambuf;
>
>
> const __ctype_type* _M_ctype;
>
> const __num_put_type* _M_num_put;
>
> const __num_get_type* _M_num_get;
>
> public:
># 117 "/usr/include/c++/8/bits/basic_ios.h" 3
> explicit operator bool() const
> { return !this->fail(); }
>
>
>
>
>
> bool
> operator!() const
> { return this->fail(); }
># 136 "/usr/include/c++/8/bits/basic_ios.h" 3
> iostate
> rdstate() const
> { return _M_streambuf_state; }
># 147 "/usr/include/c++/8/bits/basic_ios.h" 3
> void
> clear(iostate __state = goodbit);
>
>
>
>
>
>
>
> void
> setstate(iostate __state)
> { this->clear(this->rdstate() | __state); }
>
>
>
>
> void
> _M_setstate(iostate __state)
> {
>
>
> _M_streambuf_state |= __state;
> if (this->exceptions() & __state)
> throw;
> }
>
>
>
>
>
>
>
> bool
> good() const
> { return this->rdstate() == 0; }
>
>
>
>
>
>
>
> bool
> eof() const
> { return (this->rdstate() & eofbit) != 0; }
># 200 "/usr/include/c++/8/bits/basic_ios.h" 3
> bool
> fail() const
> { return (this->rdstate() & (badbit | failbit)) != 0; }
>
>
>
>
>
>
>
> bool
> bad() const
> { return (this->rdstate() & badbit) != 0; }
># 221 "/usr/include/c++/8/bits/basic_ios.h" 3
> iostate
> exceptions() const
> { return _M_exception; }
># 256 "/usr/include/c++/8/bits/basic_ios.h" 3
> void
> exceptions(iostate __except)
> {
> _M_exception = __except;
> this->clear(_M_streambuf_state);
> }
>
>
>
>
>
>
>
> explicit
> basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
> : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
> _M_ctype(0), _M_num_put(0), _M_num_get(0)
> { this->init(__sb); }
>
>
>
>
>
>
>
> virtual
> ~basic_ios() { }
># 294 "/usr/include/c++/8/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie() const
> { return _M_tie; }
># 306 "/usr/include/c++/8/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie(basic_ostream<_CharT, _Traits>* __tiestr)
> {
> basic_ostream<_CharT, _Traits>* __old = _M_tie;
> _M_tie = __tiestr;
> return __old;
> }
>
>
>
>
>
>
>
> basic_streambuf<_CharT, _Traits>*
> rdbuf() const
> { return _M_streambuf; }
># 346 "/usr/include/c++/8/bits/basic_ios.h" 3
> basic_streambuf<_CharT, _Traits>*
> rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
># 360 "/usr/include/c++/8/bits/basic_ios.h" 3
> basic_ios&
> copyfmt(const basic_ios& __rhs);
>
>
>
>
>
>
>
> char_type
> fill() const
> {
> if (!_M_fill_init)
> {
> _M_fill = this->widen(' ');
> _M_fill_init = true;
> }
> return _M_fill;
> }
># 389 "/usr/include/c++/8/bits/basic_ios.h" 3
> char_type
> fill(char_type __ch)
> {
> char_type __old = this->fill();
> _M_fill = __ch;
> return __old;
> }
># 409 "/usr/include/c++/8/bits/basic_ios.h" 3
> locale
> imbue(const locale& __loc);
># 429 "/usr/include/c++/8/bits/basic_ios.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return __check_facet(_M_ctype).narrow(__c, __dfault); }
># 448 "/usr/include/c++/8/bits/basic_ios.h" 3
> char_type
> widen(char __c) const
> { return __check_facet(_M_ctype).widen(__c); }
>
> protected:
>
>
>
>
>
>
>
> basic_ios()
> : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
> _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
> { }
>
>
>
>
>
>
>
> void
> init(basic_streambuf<_CharT, _Traits>* __sb);
>
>
> basic_ios(const basic_ios&) = delete;
> basic_ios& operator=(const basic_ios&) = delete;
>
> void
> move(basic_ios& __rhs)
> {
> ios_base::_M_move(__rhs);
> _M_cache_locale(_M_ios_locale);
> this->tie(__rhs.tie(nullptr));
> _M_fill = __rhs._M_fill;
> _M_fill_init = __rhs._M_fill_init;
> _M_streambuf = nullptr;
> }
>
> void
> move(basic_ios&& __rhs)
> { this->move(__rhs); }
>
> void
> swap(basic_ios& __rhs) noexcept
> {
> ios_base::_M_swap(__rhs);
> _M_cache_locale(_M_ios_locale);
> __rhs._M_cache_locale(__rhs._M_ios_locale);
> std::swap(_M_tie, __rhs._M_tie);
> std::swap(_M_fill, __rhs._M_fill);
> std::swap(_M_fill_init, __rhs._M_fill_init);
> }
>
> void
> set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
> { _M_streambuf = __sb; }
>
>
> void
> _M_cache_locale(const locale& __loc);
> };
>
>
>}
>
># 1 "/usr/include/c++/8/bits/basic_ios.tcc" 1 3
># 33 "/usr/include/c++/8/bits/basic_ios.tcc" 3
> 
># 34 "/usr/include/c++/8/bits/basic_ios.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::clear(iostate __state)
> {
> if (this->rdbuf())
> _M_streambuf_state = __state;
> else
> _M_streambuf_state = __state | badbit;
> if (this->exceptions() & this->rdstate())
> __throw_ios_failure(("basic_ios::clear"));
> }
>
> template<typename _CharT, typename _Traits>
> basic_streambuf<_CharT, _Traits>*
> basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
> {
> basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
> _M_streambuf = __sb;
> this->clear();
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ios<_CharT, _Traits>&
> basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
> {
>
>
> if (this != &__rhs)
> {
>
>
>
>
> _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
> _M_local_word : new _Words[__rhs._M_word_size];
>
>
> _Callback_list* __cb = __rhs._M_callbacks;
> if (__cb)
> __cb->_M_add_reference();
> _M_call_callbacks(erase_event);
> if (_M_word != _M_local_word)
> {
> delete [] _M_word;
> _M_word = 0;
> }
> _M_dispose_callbacks();
>
>
> _M_callbacks = __cb;
> for (int __i = 0; __i < __rhs._M_word_size; ++__i)
> __words[__i] = __rhs._M_word[__i];
> _M_word = __words;
> _M_word_size = __rhs._M_word_size;
>
> this->flags(__rhs.flags());
> this->width(__rhs.width());
> this->precision(__rhs.precision());
> this->tie(__rhs.tie());
> this->fill(__rhs.fill());
> _M_ios_locale = __rhs.getloc();
> _M_cache_locale(_M_ios_locale);
>
> _M_call_callbacks(copyfmt_event);
>
>
> this->exceptions(__rhs.exceptions());
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> locale
> basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
> {
> locale __old(this->getloc());
> ios_base::imbue(__loc);
> _M_cache_locale(__loc);
> if (this->rdbuf() != 0)
> this->rdbuf()->pubimbue(__loc);
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
> {
>
> ios_base::_M_init();
>
>
> _M_cache_locale(_M_ios_locale);
># 146 "/usr/include/c++/8/bits/basic_ios.tcc" 3
> _M_fill = _CharT();
> _M_fill_init = false;
>
> _M_tie = 0;
> _M_exception = goodbit;
> _M_streambuf = __sb;
> _M_streambuf_state = __sb ? goodbit : badbit;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
> {
> if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
> _M_ctype = std::__addressof(use_facet<__ctype_type>(__loc));
> else
> _M_ctype = 0;
>
> if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
> _M_num_put = std::__addressof(use_facet<__num_put_type>(__loc));
> else
> _M_num_put = 0;
>
> if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
> _M_num_get = std::__addressof(use_facet<__num_get_type>(__loc));
> else
> _M_num_get = 0;
> }
>
>
>
>
> extern template class basic_ios<char>;
>
>
> extern template class basic_ios<wchar_t>;
>
>
>
>
>}
># 517 "/usr/include/c++/8/bits/basic_ios.h" 2 3
># 45 "/usr/include/c++/8/ios" 2 3
># 39 "/usr/include/c++/8/ostream" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/8/ostream" 3
> template<typename _CharT, typename _Traits>
> class basic_ostream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef ctype<_CharT> __ctype_type;
># 83 "/usr/include/c++/8/ostream" 3
> explicit
> basic_ostream(__streambuf_type* __sb)
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_ostream() { }
>
>
> class sentry;
> friend class sentry;
># 107 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> operator<<(__ostream_type& (*__pf)(__ostream_type&))
> {
>
>
>
> return __pf(*this);
> }
>
> __ostream_type&
> operator<<(__ios_type& (*__pf)(__ios_type&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
>
> __ostream_type&
> operator<<(ios_base& (*__pf) (ios_base&))
> {
>
>
>
> __pf(*this);
> return *this;
> }
># 165 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> operator<<(long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(unsigned long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(bool __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(short __n);
>
> __ostream_type&
> operator<<(unsigned short __n)
> {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
> }
>
> __ostream_type&
> operator<<(int __n);
>
> __ostream_type&
> operator<<(unsigned int __n)
> {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
> }
>
>
> __ostream_type&
> operator<<(long long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(unsigned long long __n)
> { return _M_insert(__n); }
># 219 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> operator<<(double __f)
> { return _M_insert(__f); }
>
> __ostream_type&
> operator<<(float __f)
> {
>
>
> return _M_insert(static_cast<double>(__f));
> }
>
> __ostream_type&
> operator<<(long double __f)
> { return _M_insert(__f); }
># 244 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> operator<<(const void* __p)
> { return _M_insert(__p); }
># 269 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> operator<<(__streambuf_type* __sb);
># 302 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> put(char_type __c);
>
>
>
>
>
>
> void
> _M_write(const char_type* __s, streamsize __n)
> {
> const streamsize __put = this->rdbuf()->sputn(__s, __n);
> if (__put != __n)
> this->setstate(ios_base::badbit);
> }
># 334 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> write(const char_type* __s, streamsize __n);
># 347 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> flush();
># 357 "/usr/include/c++/8/ostream" 3
> pos_type
> tellp();
># 368 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> seekp(pos_type);
># 380 "/usr/include/c++/8/ostream" 3
> __ostream_type&
> seekp(off_type, ios_base::seekdir);
>
> protected:
> basic_ostream()
> { this->init(0); }
>
>
>
> basic_ostream(basic_iostream<_CharT, _Traits>&) { }
>
> basic_ostream(const basic_ostream&) = delete;
>
> basic_ostream(basic_ostream&& __rhs)
> : __ios_type()
> { __ios_type::move(__rhs); }
>
>
>
> basic_ostream& operator=(const basic_ostream&) = delete;
>
> basic_ostream&
> operator=(basic_ostream&& __rhs)
> {
> swap(__rhs);
> return *this;
> }
>
> void
> swap(basic_ostream& __rhs)
> { __ios_type::swap(__rhs); }
>
>
> template<typename _ValueT>
> __ostream_type&
> _M_insert(_ValueT __v);
> };
># 425 "/usr/include/c++/8/ostream" 3
> template <typename _CharT, typename _Traits>
> class basic_ostream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
> basic_ostream<_CharT, _Traits>& _M_os;
>
> public:
># 444 "/usr/include/c++/8/ostream" 3
> explicit
> sentry(basic_ostream<_CharT, _Traits>& __os);
># 454 "/usr/include/c++/8/ostream" 3
> ~sentry()
> {
>
> if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
> {
>
> if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
> _M_os.setstate(ios_base::badbit);
> }
> }
># 473 "/usr/include/c++/8/ostream" 3
> explicit
>
> operator bool() const
> { return _M_ok; }
> };
># 495 "/usr/include/c++/8/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
> { return __ostream_insert(__out, &__c, 1); }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
> { return (__out << __out.widen(__c)); }
>
>
> template <class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c)
> { return __ostream_insert(__out, &__c, 1); }
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
> { return (__out << static_cast<char>(__c)); }
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
> { return (__out << static_cast<char>(__c)); }
># 537 "/usr/include/c++/8/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> __ostream_insert(__out, __s,
> static_cast<streamsize>(_Traits::length(__s)));
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits> &
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
>
>
> template<class _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<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
>
> template<class _Traits>
> inline basic_ostream<char, _Traits> &
> operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
># 588 "/usr/include/c++/8/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'))); }
># 600 "/usr/include/c++/8/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> ends(basic_ostream<_CharT, _Traits>& __os)
> { return __os.put(_CharT()); }
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> flush(basic_ostream<_CharT, _Traits>& __os)
> { return __os.flush(); }
>
>
> template<typename _Ch, typename _Up>
> basic_ostream<_Ch, _Up>&
> __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);
>
> template<typename _Tp, typename = void>
> struct __is_convertible_to_basic_ostream_impl
> {
> using __ostream_type = void;
> };
>
> template<typename _Tp>
> using __do_is_convertible_to_basic_ostream_impl =
> decltype(__is_convertible_to_basic_ostream_test
> (declval<typename remove_reference<_Tp>::type*>()));
>
> template<typename _Tp>
> struct __is_convertible_to_basic_ostream_impl
> <_Tp,
> __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
> {
> using __ostream_type =
> __do_is_convertible_to_basic_ostream_impl<_Tp>;
> };
>
> template<typename _Tp>
> struct __is_convertible_to_basic_ostream
> : __is_convertible_to_basic_ostream_impl<_Tp>
> {
> public:
> using type = __not_<is_void<
> typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
> constexpr static bool value = type::value;
> };
>
> template<typename _Ostream, typename _Tp, typename = void>
> struct __is_insertable : false_type {};
>
> template<typename _Ostream, typename _Tp>
> struct __is_insertable<_Ostream, _Tp,
> __void_t<decltype(declval<_Ostream&>()
> << declval<const _Tp&>())>>
> : true_type {};
>
> template<typename _Ostream>
> using __rvalue_ostream_type =
> typename __is_convertible_to_basic_ostream<
> _Ostream>::__ostream_type;
># 674 "/usr/include/c++/8/ostream" 3
> template<typename _Ostream, typename _Tp>
> inline
> typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
> __is_convertible_to_basic_ostream<_Ostream>,
> __is_insertable<
> __rvalue_ostream_type<_Ostream>,
> const _Tp&>>::value,
> __rvalue_ostream_type<_Ostream>>::type
> operator<<(_Ostream&& __os, const _Tp& __x)
> {
> __rvalue_ostream_type<_Ostream> __ret_os = __os;
> __ret_os << __x;
> return __ret_os;
> }
>
>
>
>}
>
># 1 "/usr/include/c++/8/bits/ostream.tcc" 1 3
># 37 "/usr/include/c++/8/bits/ostream.tcc" 3
> 
># 38 "/usr/include/c++/8/bits/ostream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>::sentry::
> sentry(basic_ostream<_CharT, _Traits>& __os)
> : _M_ok(false), _M_os(__os)
> {
>
> if (__os.tie() && __os.good())
> __os.tie()->flush();
>
> if (__os.good())
> _M_ok = true;
> else
> __os.setstate(ios_base::failbit);
> }
>
> template<typename _CharT, typename _Traits>
> template<typename _ValueT>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> _M_insert(_ValueT __v)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __v).failed())
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(short __n)
> {
>
>
> const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
> else
> return _M_insert(static_cast<long>(__n));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(int __n)
> {
>
>
> const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
> else
> return _M_insert(static_cast<long>(__n));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__streambuf_type* __sbin)
> {
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this);
> if (__cerb && __sbin)
> {
> try
> {
> if (!__copy_streambufs(__sbin, this->rdbuf()))
> __err |= ios_base::failbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbin)
> __err |= ios_base::badbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> put(char_type __c)
> {
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __put = this->rdbuf()->sputc(__c);
> if (traits_type::eq_int_type(__put, traits_type::eof()))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> write(const _CharT* __s, streamsize __n)
> {
>
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> try
> { _M_write(__s, __n); }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> flush()
> {
>
>
>
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_ostream<_CharT, _Traits>::pos_type
> basic_ostream<_CharT, _Traits>::
> tellp()
> {
> pos_type __ret = pos_type(-1);
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(pos_type __pos)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(off_type __off, ios_base::seekdir __dir)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> {
>
>
> const size_t __clen = char_traits<char>::length(__s);
> try
> {
> struct __ptr_guard
> {
> _CharT *__p;
> __ptr_guard (_CharT *__ip): __p(__ip) { }
> ~__ptr_guard() { delete[] __p; }
> _CharT* __get() { return __p; }
> } __pg (new _CharT[__clen]);
>
> _CharT *__ws = __pg.__get();
> for (size_t __i = 0; __i < __clen; ++__i)
> __ws[__i] = __out.widen(__s[__i]);
> __ostream_insert(__out, __ws, __clen);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __out._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __out._M_setstate(ios_base::badbit); }
> }
> return __out;
> }
>
>
>
>
> extern template class basic_ostream<char>;
> extern template ostream& endl(ostream&);
> extern template ostream& ends(ostream&);
> extern template ostream& flush(ostream&);
> extern template ostream& operator<<(ostream&, char);
> extern template ostream& operator<<(ostream&, unsigned char);
> extern template ostream& operator<<(ostream&, signed char);
> extern template ostream& operator<<(ostream&, const char*);
> extern template ostream& operator<<(ostream&, const unsigned char*);
> extern template ostream& operator<<(ostream&, const signed char*);
>
> extern template ostream& ostream::_M_insert(long);
> extern template ostream& ostream::_M_insert(unsigned long);
> extern template ostream& ostream::_M_insert(bool);
>
> extern template ostream& ostream::_M_insert(long long);
> extern template ostream& ostream::_M_insert(unsigned long long);
>
> extern template ostream& ostream::_M_insert(double);
> extern template ostream& ostream::_M_insert(long double);
> extern template ostream& ostream::_M_insert(const void*);
>
>
> extern template class basic_ostream<wchar_t>;
> extern template wostream& endl(wostream&);
> extern template wostream& ends(wostream&);
> extern template wostream& flush(wostream&);
> extern template wostream& operator<<(wostream&, wchar_t);
> extern template wostream& operator<<(wostream&, char);
> extern template wostream& operator<<(wostream&, const wchar_t*);
> extern template wostream& operator<<(wostream&, const char*);
>
> extern template wostream& wostream::_M_insert(long);
> extern template wostream& wostream::_M_insert(unsigned long);
> extern template wostream& wostream::_M_insert(bool);
>
> extern template wostream& wostream::_M_insert(long long);
> extern template wostream& wostream::_M_insert(unsigned long long);
>
> extern template wostream& wostream::_M_insert(double);
> extern template wostream& wostream::_M_insert(long double);
> extern template wostream& wostream::_M_insert(const void*);
>
>
>
>
>}
># 694 "/usr/include/c++/8/ostream" 2 3
># 40 "/usr/include/c++/8/iostream" 2 3
># 1 "/usr/include/c++/8/istream" 1 3
># 36 "/usr/include/c++/8/istream" 3
> 
># 37 "/usr/include/c++/8/istream" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/8/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
> typedef ctype<_CharT> __ctype_type;
>
> protected:
>
>
>
>
>
> streamsize _M_gcount;
>
> public:
>
>
>
>
>
>
>
> explicit
> basic_istream(__streambuf_type* __sb)
> : _M_gcount(streamsize(0))
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_istream()
> { _M_gcount = streamsize(0); }
>
>
> class sentry;
> friend class sentry;
># 119 "/usr/include/c++/8/istream" 3
> __istream_type&
> operator>>(__istream_type& (*__pf)(__istream_type&))
> { return __pf(*this); }
>
> __istream_type&
> operator>>(__ios_type& (*__pf)(__ios_type&))
> {
> __pf(*this);
> return *this;
> }
>
> __istream_type&
> operator>>(ios_base& (*__pf)(ios_base&))
> {
> __pf(*this);
> return *this;
> }
># 167 "/usr/include/c++/8/istream" 3
> __istream_type&
> operator>>(bool& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(short& __n);
>
> __istream_type&
> operator>>(unsigned short& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(int& __n);
>
> __istream_type&
> operator>>(unsigned int& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(long& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(unsigned long& __n)
> { return _M_extract(__n); }
>
>
> __istream_type&
> operator>>(long long& __n)
> { return _M_extract(__n); }
>
> __istream_type&
> operator>>(unsigned long long& __n)
> { return _M_extract(__n); }
># 213 "/usr/include/c++/8/istream" 3
> __istream_type&
> operator>>(float& __f)
> { return _M_extract(__f); }
>
> __istream_type&
> operator>>(double& __f)
> { return _M_extract(__f); }
>
> __istream_type&
> operator>>(long double& __f)
> { return _M_extract(__f); }
># 234 "/usr/include/c++/8/istream" 3
> __istream_type&
> operator>>(void*& __p)
> { return _M_extract(__p); }
># 258 "/usr/include/c++/8/istream" 3
> __istream_type&
> operator>>(__streambuf_type* __sb);
># 268 "/usr/include/c++/8/istream" 3
> streamsize
> gcount() const
> { return _M_gcount; }
># 301 "/usr/include/c++/8/istream" 3
> int_type
> get();
># 315 "/usr/include/c++/8/istream" 3
> __istream_type&
> get(char_type& __c);
># 342 "/usr/include/c++/8/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n, char_type __delim);
># 353 "/usr/include/c++/8/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n)
> { return this->get(__s, __n, this->widen('\n')); }
># 376 "/usr/include/c++/8/istream" 3
> __istream_type&
> get(__streambuf_type& __sb, char_type __delim);
># 386 "/usr/include/c++/8/istream" 3
> __istream_type&
> get(__streambuf_type& __sb)
> { return this->get(__sb, this->widen('\n')); }
># 415 "/usr/include/c++/8/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n, char_type __delim);
># 426 "/usr/include/c++/8/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n)
> { return this->getline(__s, __n, this->widen('\n')); }
># 450 "/usr/include/c++/8/istream" 3
> __istream_type&
> ignore(streamsize __n, int_type __delim);
>
> __istream_type&
> ignore(streamsize __n);
>
> __istream_type&
> ignore();
># 467 "/usr/include/c++/8/istream" 3
> int_type
> peek();
># 485 "/usr/include/c++/8/istream" 3
> __istream_type&
> read(char_type* __s, streamsize __n);
># 504 "/usr/include/c++/8/istream" 3
> streamsize
> readsome(char_type* __s, streamsize __n);
># 521 "/usr/include/c++/8/istream" 3
> __istream_type&
> putback(char_type __c);
># 537 "/usr/include/c++/8/istream" 3
> __istream_type&
> unget();
># 555 "/usr/include/c++/8/istream" 3
> int
> sync();
># 570 "/usr/include/c++/8/istream" 3
> pos_type
> tellg();
># 585 "/usr/include/c++/8/istream" 3
> __istream_type&
> seekg(pos_type);
># 601 "/usr/include/c++/8/istream" 3
> __istream_type&
> seekg(off_type, ios_base::seekdir);
>
>
> protected:
> basic_istream()
> : _M_gcount(streamsize(0))
> { this->init(0); }
>
>
> basic_istream(const basic_istream&) = delete;
>
> basic_istream(basic_istream&& __rhs)
> : __ios_type(), _M_gcount(__rhs._M_gcount)
> {
> __ios_type::move(__rhs);
> __rhs._M_gcount = 0;
> }
>
>
>
> basic_istream& operator=(const basic_istream&) = delete;
>
> basic_istream&
> operator=(basic_istream&& __rhs)
> {
> swap(__rhs);
> return *this;
> }
>
> void
> swap(basic_istream& __rhs)
> {
> __ios_type::swap(__rhs);
> std::swap(_M_gcount, __rhs._M_gcount);
> }
>
>
> template<typename _ValueT>
> __istream_type&
> _M_extract(_ValueT& __v);
> };
>
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n, int_type __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n, int_type __delim);
># 685 "/usr/include/c++/8/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
>
> public:
>
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef typename _Traits::int_type __int_type;
># 721 "/usr/include/c++/8/istream" 3
> explicit
> sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
># 732 "/usr/include/c++/8/istream" 3
> explicit
>
> operator bool() const
> { return _M_ok; }
> };
># 750 "/usr/include/c++/8/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
># 792 "/usr/include/c++/8/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
>
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __in, char* __s);
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
># 823 "/usr/include/c++/8/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_iostream
> : public basic_istream<_CharT, _Traits>,
> public basic_ostream<_CharT, _Traits>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
>
>
>
>
> explicit
> basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
> : __istream_type(__sb), __ostream_type(__sb) { }
>
>
>
>
> virtual
> ~basic_iostream() { }
>
> protected:
> basic_iostream()
> : __istream_type(), __ostream_type() { }
>
>
> basic_iostream(const basic_iostream&) = delete;
>
> basic_iostream(basic_iostream&& __rhs)
> : __istream_type(std::move(__rhs)), __ostream_type(*this)
> { }
>
>
>
> basic_iostream& operator=(const basic_iostream&) = delete;
>
> basic_iostream&
> operator=(basic_iostream&& __rhs)
> {
> swap(__rhs);
> return *this;
> }
>
> void
> swap(basic_iostream& __rhs)
> { __istream_type::swap(__rhs); }
>
> };
># 906 "/usr/include/c++/8/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __is);
>
>
> template<typename _Ch, typename _Up>
> basic_istream<_Ch, _Up>&
> __is_convertible_to_basic_istream_test(basic_istream<_Ch, _Up>*);
>
> template<typename _Tp, typename = void>
> struct __is_convertible_to_basic_istream_impl
> {
> using __istream_type = void;
> };
>
> template<typename _Tp>
> using __do_is_convertible_to_basic_istream_impl =
> decltype(__is_convertible_to_basic_istream_test
> (declval<typename remove_reference<_Tp>::type*>()));
>
> template<typename _Tp>
> struct __is_convertible_to_basic_istream_impl
> <_Tp,
> __void_t<__do_is_convertible_to_basic_istream_impl<_Tp>>>
> {
> using __istream_type =
> __do_is_convertible_to_basic_istream_impl<_Tp>;
> };
>
> template<typename _Tp>
> struct __is_convertible_to_basic_istream
> : __is_convertible_to_basic_istream_impl<_Tp>
> {
> public:
> using type = __not_<is_void<
> typename __is_convertible_to_basic_istream_impl<_Tp>::__istream_type>>;
> constexpr static bool value = type::value;
> };
>
> template<typename _Istream, typename _Tp, typename = void>
> struct __is_extractable : false_type {};
>
> template<typename _Istream, typename _Tp>
> struct __is_extractable<_Istream, _Tp,
> __void_t<decltype(declval<_Istream&>()
> >> declval<_Tp>())>>
> : true_type {};
>
> template<typename _Istream>
> using __rvalue_istream_type =
> typename __is_convertible_to_basic_istream<
> _Istream>::__istream_type;
># 972 "/usr/include/c++/8/istream" 3
> template<typename _Istream, typename _Tp>
> inline
> typename enable_if<__and_<__not_<is_lvalue_reference<_Istream>>,
> __is_convertible_to_basic_istream<_Istream>,
> __is_extractable<
> __rvalue_istream_type<_Istream>,
> _Tp&&>>::value,
> __rvalue_istream_type<_Istream>>::type
> operator>>(_Istream&& __is, _Tp&& __x)
> {
> __rvalue_istream_type<_Istream> __ret_is = __is;
> __ret_is >> std::forward<_Tp>(__x);
> return __ret_is;
> }
>
>
>
>}
>
># 1 "/usr/include/c++/8/bits/istream.tcc" 1 3
># 37 "/usr/include/c++/8/bits/istream.tcc" 3
> 
># 38 "/usr/include/c++/8/bits/istream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>::sentry::
> sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
> {
> ios_base::iostate __err = ios_base::goodbit;
> if (__in.good())
> try
> {
> if (__in.tie())
> __in.tie()->flush();
> if (!__noskip && bool(__in.flags() & ios_base::skipws))
> {
> const __int_type __eof = traits_type::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> const __ctype_type& __ct = __check_facet(__in._M_ctype);
> while (!traits_type::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space,
> traits_type::to_char_type(__c)))
> __c = __sb->snextc();
>
>
>
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
>
> if (__in.good() && __err == ios_base::goodbit)
> _M_ok = true;
> else
> {
> __err |= ios_base::failbit;
> __in.setstate(__err);
> }
> }
>
> template<typename _CharT, typename _Traits>
> template<typename _ValueT>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> _M_extract(_ValueT& __v)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __v);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(short& __n)
> {
>
>
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
>
> if (__l < __gnu_cxx::__numeric_traits<short>::__min)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<short>::__min;
> }
> else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<short>::__max;
> }
> else
> __n = short(__l);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(int& __n)
> {
>
>
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
>
> if (__l < __gnu_cxx::__numeric_traits<int>::__min)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<int>::__min;
> }
> else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<int>::__max;
> }
> else
> __n = int(__l);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__streambuf_type* __sbout)
> {
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, false);
> if (__cerb && __sbout)
> {
> try
> {
> bool __ineof;
> if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
> __err |= ios_base::failbit;
> if (__ineof)
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::failbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbout)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> get(void)
> {
> const int_type __eof = traits_type::eof();
> int_type __c = __eof;
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> __c = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__c, __eof))
> _M_gcount = 1;
> else
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type& __c)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __cb = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__cb, traits_type::eof()))
> {
> _M_gcount = 1;
> __c = traits_type::to_char_type(__cb);
> }
> else
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(__streambuf_type& __sb, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __this_sb = this->rdbuf();
> int_type __c = __this_sb->sgetc();
> char_type __c2 = traits_type::to_char_type(__c);
>
> while (!traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim)
> && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
> {
> ++_M_gcount;
> __c = __this_sb->snextc();
> __c2 = traits_type::to_char_type(__c);
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> getline(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> ++_M_gcount;
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else
> {
> if (traits_type::eq_int_type(__c, __idelim))
> {
> __sb->sbumpc();
> ++_M_gcount;
> }
> else
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(void)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
>
> if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
> __err |= ios_base::eofbit;
> else
> _M_gcount = 1;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
># 521 "/usr/include/c++/8/bits/istream.tcc" 3
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
> && !traits_type::eq_int_type(__c, __eof))
> {
> _M_gcount =
> __gnu_cxx::__numeric_traits<streamsize>::__min;
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n, int_type __delim)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
>
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> _M_gcount =
> __gnu_cxx::__numeric_traits<streamsize>::__min;
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else if (traits_type::eq_int_type(__c, __delim))
> {
> if (_M_gcount
> < __gnu_cxx::__numeric_traits<streamsize>::__max)
> ++_M_gcount;
> __sb->sbumpc();
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> peek(void)
> {
> int_type __c = traits_type::eof();
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> __c = this->rdbuf()->sgetc();
> if (traits_type::eq_int_type(__c, traits_type::eof()))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> read(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> _M_gcount = this->rdbuf()->sgetn(__s, __n);
> if (_M_gcount != __n)
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_istream<_CharT, _Traits>::
> readsome(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
>
> const streamsize __num = this->rdbuf()->in_avail();
> if (__num > 0)
> _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
> else if (__num == -1)
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return _M_gcount;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> putback(char_type __c)
> {
>
>
> _M_gcount = 0;
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> unget(void)
> {
>
>
> _M_gcount = 0;
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sungetc(), __eof))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> int
> basic_istream<_CharT, _Traits>::
> sync(void)
> {
>
>
> int __ret = -1;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> __streambuf_type* __sb = this->rdbuf();
> if (__sb)
> {
> if (__sb->pubsync() == -1)
> __err |= ios_base::badbit;
> else
> __ret = 0;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::pos_type
> basic_istream<_CharT, _Traits>::
> tellg(void)
> {
>
>
> pos_type __ret = pos_type(-1);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
> ios_base::in);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(pos_type __pos)
> {
>
>
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(off_type __off, ios_base::seekdir __dir)
> {
>
>
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::int_type __int_type;
>
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __int_type __cb = __in.rdbuf()->sbumpc();
> if (!_Traits::eq_int_type(__cb, _Traits::eof()))
> __c = _Traits::to_char_type(__cb);
> else
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> if (__err)
> __in.setstate(__err);
> }
> return __in;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef typename _Traits::int_type int_type;
> typedef _CharT char_type;
> typedef ctype<_CharT> __ctype_type;
>
> streamsize __extracted = 0;
> ios_base::iostate __err = ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> streamsize __num = __in.width();
> if (__num <= 0)
> __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>
> const int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> int_type __c = __sb->sgetc();
>
> while (__extracted < __num - 1
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> *__s++ = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
>
>
>
> *__s = char_type();
> __in.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> }
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __in)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef typename __istream_type::int_type __int_type;
> typedef ctype<_CharT> __ctype_type;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (!_Traits::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
> __c = __sb->snextc();
>
> if (_Traits::eq_int_type(__c, __eof))
> __in.setstate(ios_base::eofbit);
> return __in;
> }
>
>
>
>
> extern template class basic_istream<char>;
> extern template istream& ws(istream&);
> extern template istream& operator>>(istream&, char&);
> extern template istream& operator>>(istream&, char*);
> extern template istream& operator>>(istream&, unsigned char&);
> extern template istream& operator>>(istream&, signed char&);
> extern template istream& operator>>(istream&, unsigned char*);
> extern template istream& operator>>(istream&, signed char*);
>
> extern template istream& istream::_M_extract(unsigned short&);
> extern template istream& istream::_M_extract(unsigned int&);
> extern template istream& istream::_M_extract(long&);
> extern template istream& istream::_M_extract(unsigned long&);
> extern template istream& istream::_M_extract(bool&);
>
> extern template istream& istream::_M_extract(long long&);
> extern template istream& istream::_M_extract(unsigned long long&);
>
> extern template istream& istream::_M_extract(float&);
> extern template istream& istream::_M_extract(double&);
> extern template istream& istream::_M_extract(long double&);
> extern template istream& istream::_M_extract(void*&);
>
> extern template class basic_iostream<char>;
>
>
> extern template class basic_istream<wchar_t>;
> extern template wistream& ws(wistream&);
> extern template wistream& operator>>(wistream&, wchar_t&);
> extern template wistream& operator>>(wistream&, wchar_t*);
>
> extern template wistream& wistream::_M_extract(unsigned short&);
> extern template wistream& wistream::_M_extract(unsigned int&);
> extern template wistream& wistream::_M_extract(long&);
> extern template wistream& wistream::_M_extract(unsigned long&);
> extern template wistream& wistream::_M_extract(bool&);
>
> extern template wistream& wistream::_M_extract(long long&);
> extern template wistream& wistream::_M_extract(unsigned long long&);
>
> extern template wistream& wistream::_M_extract(float&);
> extern template wistream& wistream::_M_extract(double&);
> extern template wistream& wistream::_M_extract(long double&);
> extern template wistream& wistream::_M_extract(void*&);
>
> extern template class basic_iostream<wchar_t>;
>
>
>
>
>}
># 992 "/usr/include/c++/8/istream" 2 3
># 41 "/usr/include/c++/8/iostream" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 60 "/usr/include/c++/8/iostream" 3
> extern istream cin;
> extern ostream cout;
> extern ostream cerr;
> extern ostream clog;
>
>
> extern wistream wcin;
> extern wostream wcout;
> extern wostream wcerr;
> extern wostream wclog;
>
>
>
>
> static ios_base::Init __ioinit;
>
>
>}
># 2 "h2-client.cpp" 2
>
># 1 "/usr/local/include/fmt/format.h" 1 3
># 31 "/usr/local/include/fmt/format.h" 3
># 1 "/usr/include/c++/8/algorithm" 1 3
># 58 "/usr/include/c++/8/algorithm" 3
> 
># 59 "/usr/include/c++/8/algorithm" 3
>
># 1 "/usr/include/c++/8/utility" 1 3
># 58 "/usr/include/c++/8/utility" 3
> 
># 59 "/usr/include/c++/8/utility" 3
># 69 "/usr/include/c++/8/utility" 3
># 1 "/usr/include/c++/8/bits/stl_relops.h" 1 3
># 67 "/usr/include/c++/8/bits/stl_relops.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> namespace rel_ops
> {
># 85 "/usr/include/c++/8/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator!=(const _Tp& __x, const _Tp& __y)
> { return !(__x == __y); }
># 98 "/usr/include/c++/8/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>(const _Tp& __x, const _Tp& __y)
> { return __y < __x; }
># 111 "/usr/include/c++/8/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator<=(const _Tp& __x, const _Tp& __y)
> { return !(__y < __x); }
># 124 "/usr/include/c++/8/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>=(const _Tp& __x, const _Tp& __y)
> { return !(__x < __y); }
> }
>
>
>}
># 70 "/usr/include/c++/8/utility" 2 3
># 82 "/usr/include/c++/8/utility" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Tp>
> struct tuple_size;
>
>
>
>
>
> template<typename _Tp,
> typename _Up = typename remove_cv<_Tp>::type,
> typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
> size_t = tuple_size<_Tp>::value>
> using __enable_if_has_tuple_size = _Tp;
>
> template<typename _Tp>
> struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
> : public tuple_size<_Tp> { };
>
> template<typename _Tp>
> struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
> : public tuple_size<_Tp> { };
>
> template<typename _Tp>
> struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
> : public tuple_size<_Tp> { };
>
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element;
>
>
> template<std::size_t __i, typename _Tp>
> using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const _Tp>
> {
> typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, volatile _Tp>
> {
> typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const volatile _Tp>
> {
> typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
> };
>
>
>
>
> template<std::size_t __i, typename _Tp>
> using tuple_element_t = typename tuple_element<__i, _Tp>::type;
>
>
>
>
>
> template<typename _T1, typename _T2>
> struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
> { };
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_size<std::pair<_Tp1, _Tp2>>
> : public integral_constant<std::size_t, 2> { };
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_element<0, std::pair<_Tp1, _Tp2>>
> { typedef _Tp1 type; };
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_element<1, std::pair<_Tp1, _Tp2>>
> { typedef _Tp2 type; };
>
> template<std::size_t _Int>
> struct __pair_get;
>
> template<>
> struct __pair_get<0>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp1>(__pair.first); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp1&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp1&&
> __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<const _Tp1>(__pair.first); }
> };
>
> template<>
> struct __pair_get<1>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp2>(__pair.second); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp2&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp2&&
> __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<const _Tp2>(__pair.second); }
> };
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__get(__in); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
> get(std::pair<_Tp1, _Tp2>&& __in) noexcept
> { return __pair_get<_Int>::__move_get(std::move(__in)); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(const std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__const_get(__in); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
> get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
> { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
>
>
>
>
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&
> get(pair<_Tp, _Up>& __p) noexcept
> { return __p.first; }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&
> get(const pair<_Tp, _Up>& __p) noexcept
> { return __p.first; }
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&&
> get(pair<_Tp, _Up>&& __p) noexcept
> { return std::move(__p.first); }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&&
> get(const pair<_Tp, _Up>&& __p) noexcept
> { return std::move(__p.first); }
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&
> get(pair<_Up, _Tp>& __p) noexcept
> { return __p.second; }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&
> get(const pair<_Up, _Tp>& __p) noexcept
> { return __p.second; }
>
> template <typename _Tp, typename _Up>
> constexpr _Tp&&
> get(pair<_Up, _Tp>&& __p) noexcept
> { return std::move(__p.second); }
>
> template <typename _Tp, typename _Up>
> constexpr const _Tp&&
> get(const pair<_Up, _Tp>&& __p) noexcept
> { return std::move(__p.second); }
>
>
>
>
> template <typename _Tp, typename _Up = _Tp>
> inline _Tp
> exchange(_Tp& __obj, _Up&& __new_val)
> { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
>
>
>
>
> template<size_t... _Indexes> struct _Index_tuple { };
># 302 "/usr/include/c++/8/utility" 3
> template<size_t _Num>
> struct _Build_index_tuple
> {
>
>
>
>
>
>
> using __type = _Index_tuple<__integer_pack(_Num)...>;
>
> };
>
>
>
>
>
>
> template<typename _Tp, _Tp... _Idx>
> struct integer_sequence
> {
> typedef _Tp value_type;
> static constexpr size_t size() noexcept { return sizeof...(_Idx); }
> };
>
>
> template<typename _Tp, _Tp _Num>
> using make_integer_sequence
>
>
>
> = integer_sequence<_Tp, __integer_pack(_Num)...>;
>
>
>
>
>
> template<size_t... _Idx>
> using index_sequence = integer_sequence<size_t, _Idx...>;
>
>
> template<size_t _Num>
> using make_index_sequence = make_integer_sequence<size_t, _Num>;
>
>
> template<typename... _Types>
> using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
>
>
>
>
> struct in_place_t {
> explicit in_place_t() = default;
> };
>
> inline constexpr in_place_t in_place{};
>
> template<typename _Tp> struct in_place_type_t
> {
> explicit in_place_type_t() = default;
> };
>
> template<typename _Tp>
> inline constexpr in_place_type_t<_Tp> in_place_type{};
>
> template<size_t _Idx> struct in_place_index_t
> {
> explicit in_place_index_t() = default;
> };
>
> template<size_t _Idx>
> inline constexpr in_place_index_t<_Idx> in_place_index{};
>
> template<typename>
> struct __is_in_place_type_impl : false_type
> { };
>
> template<typename _Tp>
> struct __is_in_place_type_impl<in_place_type_t<_Tp>> : true_type
> { };
>
> template<typename _Tp>
> struct __is_in_place_type
> : public __is_in_place_type_impl<_Tp>
> { };
>
>
> template<typename _Tp>
> constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
>
> template<typename _Tp>
> void as_const(const _Tp&&) = delete;
>
>
>
>
>}
># 61 "/usr/include/c++/8/algorithm" 2 3
>
># 1 "/usr/include/c++/8/bits/stl_algo.h" 1 3
># 59 "/usr/include/c++/8/bits/stl_algo.h" 3
># 1 "/usr/include/c++/8/cstdlib" 1 3
># 39 "/usr/include/c++/8/cstdlib" 3
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 60 "/usr/include/c++/8/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/8/bits/algorithmfwd.h" 1 3
># 33 "/usr/include/c++/8/bits/algorithmfwd.h" 3
> 
># 34 "/usr/include/c++/8/bits/algorithmfwd.h" 3
># 42 "/usr/include/c++/8/bits/algorithmfwd.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 195 "/usr/include/c++/8/bits/algorithmfwd.h" 3
> template<typename _IIter, typename _Predicate>
> bool
> all_of(_IIter, _IIter, _Predicate);
>
> template<typename _IIter, typename _Predicate>
> bool
> any_of(_IIter, _IIter, _Predicate);
>
>
> template<typename _FIter, typename _Tp>
> bool
> binary_search(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> bool
> binary_search(_FIter, _FIter, const _Tp&, _Compare);
>
>
> template<typename _Tp>
> constexpr
> const _Tp&
> clamp(const _Tp&, const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> constexpr
> const _Tp&
> clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
>
>
> template<typename _IIter, typename _OIter>
> _OIter
> copy(_IIter, _IIter, _OIter);
>
> template<typename _BIter1, typename _BIter2>
> _BIter2
> copy_backward(_BIter1, _BIter1, _BIter2);
>
>
> template<typename _IIter, typename _OIter, typename _Predicate>
> _OIter
> copy_if(_IIter, _IIter, _OIter, _Predicate);
>
> template<typename _IIter, typename _Size, typename _OIter>
> _OIter
> copy_n(_IIter, _Size, _OIter);
>
>
>
>
>
> template<typename _FIter, typename _Tp>
> pair<_FIter, _FIter>
> equal_range(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> pair<_FIter, _FIter>
> equal_range(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _FIter, typename _Tp>
> void
> fill(_FIter, _FIter, const _Tp&);
>
> template<typename _OIter, typename _Size, typename _Tp>
> _OIter
> fill_n(_OIter, _Size, const _Tp&);
>
>
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> find_end(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
>
>
>
>
> template<typename _IIter, typename _Predicate>
> _IIter
> find_if_not(_IIter, _IIter, _Predicate);
>
>
>
>
>
>
> template<typename _IIter1, typename _IIter2>
> bool
> includes(_IIter1, _IIter1, _IIter2, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _Compare>
> bool
> includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
> template<typename _BIter>
> void
> inplace_merge(_BIter, _BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> void
> inplace_merge(_BIter, _BIter, _BIter, _Compare);
>
>
> template<typename _RAIter>
> bool
> is_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> bool
> is_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> _RAIter
> is_heap_until(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> _RAIter
> is_heap_until(_RAIter, _RAIter, _Compare);
>
> template<typename _IIter, typename _Predicate>
> bool
> is_partitioned(_IIter, _IIter, _Predicate);
>
> template<typename _FIter1, typename _FIter2>
> bool
> is_permutation(_FIter1, _FIter1, _FIter2);
>
> template<typename _FIter1, typename _FIter2,
> typename _BinaryPredicate>
> bool
> is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
>
> template<typename _FIter>
> bool
> is_sorted(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> bool
> is_sorted(_FIter, _FIter, _Compare);
>
> template<typename _FIter>
> _FIter
> is_sorted_until(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> is_sorted_until(_FIter, _FIter, _Compare);
>
>
> template<typename _FIter1, typename _FIter2>
> void
> iter_swap(_FIter1, _FIter2);
>
> template<typename _FIter, typename _Tp>
> _FIter
> lower_bound(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> _FIter
> lower_bound(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _RAIter>
> void
> make_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> make_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _Tp>
> constexpr
> const _Tp&
> max(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> constexpr
> const _Tp&
> max(const _Tp&, const _Tp&, _Compare);
>
>
>
>
> template<typename _Tp>
> constexpr
> const _Tp&
> min(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> constexpr
> const _Tp&
> min(const _Tp&, const _Tp&, _Compare);
>
>
>
>
> template<typename _Tp>
> constexpr
> pair<const _Tp&, const _Tp&>
> minmax(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> constexpr
> pair<const _Tp&, const _Tp&>
> minmax(const _Tp&, const _Tp&, _Compare);
>
> template<typename _FIter>
> constexpr
> pair<_FIter, _FIter>
> minmax_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> constexpr
> pair<_FIter, _FIter>
> minmax_element(_FIter, _FIter, _Compare);
>
> template<typename _Tp>
> constexpr
> _Tp
> min(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> constexpr
> _Tp
> min(initializer_list<_Tp>, _Compare);
>
> template<typename _Tp>
> constexpr
> _Tp
> max(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> constexpr
> _Tp
> max(initializer_list<_Tp>, _Compare);
>
> template<typename _Tp>
> constexpr
> pair<_Tp, _Tp>
> minmax(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> constexpr
> pair<_Tp, _Tp>
> minmax(initializer_list<_Tp>, _Compare);
>
>
>
>
> template<typename _BIter>
> bool
> next_permutation(_BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> bool
> next_permutation(_BIter, _BIter, _Compare);
>
>
> template<typename _IIter, typename _Predicate>
> bool
> none_of(_IIter, _IIter, _Predicate);
>
>
>
>
>
> template<typename _IIter, typename _RAIter>
> _RAIter
> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
>
> template<typename _IIter, typename _RAIter, typename _Compare>
> _RAIter
> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
>
>
>
>
> template<typename _IIter, typename _OIter1,
> typename _OIter2, typename _Predicate>
> pair<_OIter1, _OIter2>
> partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
>
> template<typename _FIter, typename _Predicate>
> _FIter
> partition_point(_FIter, _FIter, _Predicate);
>
>
> template<typename _RAIter>
> void
> pop_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> pop_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _BIter>
> bool
> prev_permutation(_BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> bool
> prev_permutation(_BIter, _BIter, _Compare);
>
> template<typename _RAIter>
> void
> push_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> push_heap(_RAIter, _RAIter, _Compare);
>
>
>
> template<typename _FIter, typename _Tp>
> _FIter
> remove(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Predicate>
> _FIter
> remove_if(_FIter, _FIter, _Predicate);
>
> template<typename _IIter, typename _OIter, typename _Tp>
> _OIter
> remove_copy(_IIter, _IIter, _OIter, const _Tp&);
>
> template<typename _IIter, typename _OIter, typename _Predicate>
> _OIter
> remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
>
>
>
> template<typename _IIter, typename _OIter, typename _Tp>
> _OIter
> replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
>
> template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
> _OIter
> replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
>
>
>
> template<typename _BIter>
> void
> reverse(_BIter, _BIter);
>
> template<typename _BIter, typename _OIter>
> _OIter
> reverse_copy(_BIter, _BIter, _OIter);
>
> inline namespace _V2
> {
> template<typename _FIter>
> _FIter
> rotate(_FIter, _FIter, _FIter);
> }
>
> template<typename _FIter, typename _OIter>
> _OIter
> rotate_copy(_FIter, _FIter, _FIter, _OIter);
># 565 "/usr/include/c++/8/bits/algorithmfwd.h" 3
> template<typename _RAIter, typename _UGenerator>
> void
> shuffle(_RAIter, _RAIter, _UGenerator&&);
>
>
> template<typename _RAIter>
> void
> sort_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> sort_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _BIter, typename _Predicate>
> _BIter
> stable_partition(_BIter, _BIter, _Predicate);
># 594 "/usr/include/c++/8/bits/algorithmfwd.h" 3
> template<typename _FIter1, typename _FIter2>
> _FIter2
> swap_ranges(_FIter1, _FIter1, _FIter2);
>
>
>
> template<typename _FIter>
> _FIter
> unique(_FIter, _FIter);
>
> template<typename _FIter, typename _BinaryPredicate>
> _FIter
> unique(_FIter, _FIter, _BinaryPredicate);
>
>
>
> template<typename _FIter, typename _Tp>
> _FIter
> upper_bound(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> _FIter
> upper_bound(_FIter, _FIter, const _Tp&, _Compare);
>
>
>
> template<typename _FIter>
> _FIter
> adjacent_find(_FIter, _FIter);
>
> template<typename _FIter, typename _BinaryPredicate>
> _FIter
> adjacent_find(_FIter, _FIter, _BinaryPredicate);
>
> template<typename _IIter, typename _Tp>
> typename iterator_traits<_IIter>::difference_type
> count(_IIter, _IIter, const _Tp&);
>
> template<typename _IIter, typename _Predicate>
> typename iterator_traits<_IIter>::difference_type
> count_if(_IIter, _IIter, _Predicate);
>
> template<typename _IIter1, typename _IIter2>
> bool
> equal(_IIter1, _IIter1, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> bool
> equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
> template<typename _IIter, typename _Tp>
> _IIter
> find(_IIter, _IIter, const _Tp&);
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
> template<typename _IIter, typename _Predicate>
> _IIter
> find_if(_IIter, _IIter, _Predicate);
>
> template<typename _IIter, typename _Funct>
> _Funct
> for_each(_IIter, _IIter, _Funct);
>
> template<typename _FIter, typename _Generator>
> void
> generate(_FIter, _FIter, _Generator);
>
> template<typename _OIter, typename _Size, typename _Generator>
> _OIter
> generate_n(_OIter, _Size, _Generator);
>
> template<typename _IIter1, typename _IIter2>
> bool
> lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _Compare>
> bool
> lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
> template<typename _FIter>
> constexpr
> _FIter
> max_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> constexpr
> _FIter
> max_element(_FIter, _FIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _FIter>
> constexpr
> _FIter
> min_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> constexpr
> _FIter
> min_element(_FIter, _FIter, _Compare);
>
> template<typename _IIter1, typename _IIter2>
> pair<_IIter1, _IIter2>
> mismatch(_IIter1, _IIter1, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> pair<_IIter1, _IIter2>
> mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
> template<typename _RAIter>
> void
> nth_element(_RAIter, _RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> nth_element(_RAIter, _RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> void
> partial_sort(_RAIter, _RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
>
> template<typename _BIter, typename _Predicate>
> _BIter
> partition(_BIter, _BIter, _Predicate);
>
> template<typename _RAIter>
> void
> random_shuffle(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Generator>
> void
> random_shuffle(_RAIter, _RAIter,
>
> _Generator&&);
>
>
>
>
> template<typename _FIter, typename _Tp>
> void
> replace(_FIter, _FIter, const _Tp&, const _Tp&);
>
> template<typename _FIter, typename _Predicate, typename _Tp>
> void
> replace_if(_FIter, _FIter, _Predicate, const _Tp&);
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> search(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
> template<typename _FIter, typename _Size, typename _Tp>
> _FIter
> search_n(_FIter, _FIter, _Size, const _Tp&);
>
> template<typename _FIter, typename _Size, typename _Tp,
> typename _BinaryPredicate>
> _FIter
> search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
> _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _RAIter>
> void
> sort(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> sort(_RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> void
> stable_sort(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> stable_sort(_RAIter, _RAIter, _Compare);
>
> template<typename _IIter, typename _OIter, typename _UnaryOperation>
> _OIter
> transform(_IIter, _IIter, _OIter, _UnaryOperation);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _BinaryOperation>
> _OIter
> transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
>
> template<typename _IIter, typename _OIter>
> _OIter
> unique_copy(_IIter, _IIter, _OIter);
>
> template<typename _IIter, typename _OIter, typename _BinaryPredicate>
> _OIter
> unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
>
>
>
>}
># 61 "/usr/include/c++/8/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/8/bits/stl_heap.h" 1 3
># 62 "/usr/include/c++/8/bits/stl_heap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Compare>
> _Distance
> __is_heap_until(_RandomAccessIterator __first, _Distance __n,
> _Compare& __comp)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__comp(__first + __parent, __first + __child))
> return __child;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return __n;
> }
>
>
>
> template<typename _RandomAccessIterator, typename _Distance>
> inline bool
> __is_heap(_RandomAccessIterator __first, _Distance __n)
> {
> __gnu_cxx::__ops::_Iter_less_iter __comp;
> return std::__is_heap_until(__first, __n, __comp) == __n;
> }
>
> template<typename _RandomAccessIterator, typename _Compare,
> typename _Distance>
> inline bool
> __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
> {
> typedef __decltype(__comp) _Cmp;
> __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
> return std::__is_heap_until(__first, __n, __cmp) == __n;
> }
>
> template<typename _RandomAccessIterator>
> inline bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::__is_heap(__first, std::distance(__first, __last)); }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> return std::__is_heap(__first, std::move(__comp),
> std::distance(__first, __last));
> }
>
>
>
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
> typename _Compare>
> void
> __push_heap(_RandomAccessIterator __first,
> _Distance __holeIndex, _Distance __topIndex, _Tp __value,
> _Compare& __comp)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
> {
> *(__first + __holeIndex) = std::move(*(__first + __parent));
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = std::move(__value);
> }
># 152 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
> ;
> ;
>
> __gnu_cxx::__ops::_Iter_less_val __comp;
> _ValueType __value = std::move(*(__last - 1));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), std::move(__value), __comp);
> }
># 187 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> ;
> ;
> ;
>
> __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
> __cmp(std::move(__comp));
> _ValueType __value = std::move(*(__last - 1));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), std::move(__value), __cmp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Tp, typename _Compare>
> void
> __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __len, _Tp __value, _Compare __comp)
> {
> const _Distance __topIndex = __holeIndex;
> _Distance __secondChild = __holeIndex;
> while (__secondChild < (__len - 1) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> if (__comp(__first + __secondChild,
> __first + (__secondChild - 1)))
> __secondChild--;
> *(__first + __holeIndex) = std::move(*(__first + __secondChild));
> __holeIndex = __secondChild;
> }
> if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
> ;
> __holeIndex = __secondChild - 1;
> }
> __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
> __cmp(std::move(__comp));
> std::__push_heap(__first, __holeIndex, __topIndex,
> std::move(__value), __cmp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result, _Compare& __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> _ValueType __value = std::move(*__result);
> *__result = std::move(*__first);
> std::__adjust_heap(__first, _DistanceType(0),
> _DistanceType(__last - __first),
> std::move(__value), __comp);
> }
># 269 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
> ;
> ;
>
> if (__last - __first > 1)
> {
> --__last;
> __gnu_cxx::__ops::_Iter_less_iter __comp;
> std::__pop_heap(__first, __last, __last, __comp);
> }
> }
># 302 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> pop_heap(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
>
> 
>
> ;
> ;
> ;
> ;
>
> if (__last - __first > 1)
> {
> typedef __decltype(__comp) _Cmp;
> __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
> --__last;
> std::__pop_heap(__first, __last, __last, __cmp);
> }
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> 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--;
> }
> }
># 358 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> __gnu_cxx::__ops::_Iter_less_iter __comp;
> std::__make_heap(__first, __last, __comp);
> }
># 384 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> typedef __decltype(__comp) _Cmp;
> __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
> std::__make_heap(__first, __last, __cmp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare& __comp)
> {
> while (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last, __comp);
> }
> }
># 420 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
> ;
>
> __gnu_cxx::__ops::_Iter_less_iter __comp;
> std::__sort_heap(__first, __last, __comp);
> }
># 447 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
> ;
>
> typedef __decltype(__comp) _Cmp;
> __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
> std::__sort_heap(__first, __last, __cmp);
> }
># 475 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline _RandomAccessIterator
> is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> __gnu_cxx::__ops::_Iter_less_iter __comp;
> return __first +
> std::__is_heap_until(__first, std::distance(__first, __last), __comp);
> }
># 503 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline _RandomAccessIterator
> is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> typedef __decltype(__comp) _Cmp;
> __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
> return __first
> + std::__is_heap_until(__first, std::distance(__first, __last), __cmp);
> }
># 527 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline bool
> is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::is_heap_until(__first, __last) == __last; }
># 540 "/usr/include/c++/8/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline bool
> is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> const auto __dist = std::distance(__first, __last);
> typedef __decltype(__comp) _Cmp;
> __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
> return std::__is_heap_until(__first, __dist, __cmp) == __dist;
> }
>
>
>
>}
># 62 "/usr/include/c++/8/bits/stl_algo.h" 2 3
># 1 "/usr/include/c++/8/bits/stl_tempbuf.h" 1 3
># 60 "/usr/include/c++/8/bits/stl_tempbuf.h" 3
># 1 "/usr/include/c++/8/bits/stl_construct.h" 1 3
># 63 "/usr/include/c++/8/bits/stl_construct.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _T1, typename... _Args>
> inline void
> _Construct(_T1* __p, _Args&&... __args)
> { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
># 87 "/usr/include/c++/8/bits/stl_construct.h" 3
> template<typename _T1>
> inline void
> _Construct_novalue(_T1* __p)
> { ::new(static_cast<void*>(__p)) _T1; }
>
>
>
>
> template<typename _Tp>
> inline void
> _Destroy(_Tp* __pointer)
> { __pointer->~_Tp(); }
>
> template<bool>
> struct _Destroy_aux
> {
> template<typename _ForwardIterator>
> static void
> __destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> for (; __first != __last; ++__first)
> std::_Destroy(std::__addressof(*__first));
> }
> };
>
> template<>
> struct _Destroy_aux<true>
> {
> template<typename _ForwardIterator>
> static void
> __destroy(_ForwardIterator, _ForwardIterator) { }
> };
>
>
>
>
>
>
> template<typename _ForwardIterator>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _Value_type;
>
>
> static_assert(is_destructible<_Value_type>::value,
> "value type is destructible");
>
> std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
> __destroy(__first, __last);
> }
>
> template<bool>
> struct _Destroy_n_aux
> {
> template<typename _ForwardIterator, typename _Size>
> static _ForwardIterator
> __destroy_n(_ForwardIterator __first, _Size __count)
> {
> for (; __count > 0; (void)++__first, --__count)
> std::_Destroy(std::__addressof(*__first));
> return __first;
> }
> };
>
> template<>
> struct _Destroy_n_aux<true>
> {
> template<typename _ForwardIterator, typename _Size>
> static _ForwardIterator
> __destroy_n(_ForwardIterator __first, _Size __count)
> {
> std::advance(__first, __count);
> return __first;
> }
> };
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Size>
> inline _ForwardIterator
> _Destroy_n(_ForwardIterator __first, _Size __count)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _Value_type;
>
>
> static_assert(is_destructible<_Value_type>::value,
> "value type is destructible");
>
> return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
> __destroy_n(__first, __count);
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Allocator>
> void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> _Allocator& __alloc)
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __first != __last; ++__first)
> __traits::destroy(__alloc, std::__addressof(*__first));
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> allocator<_Tp>&)
> {
> _Destroy(__first, __last);
> }
>
>
> template <typename _Tp>
> inline void
> destroy_at(_Tp* __location)
> {
> std::_Destroy(__location);
> }
>
> template <typename _ForwardIterator>
> inline void
> destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> std::_Destroy(__first, __last);
> }
>
> template <typename _ForwardIterator, typename _Size>
> inline _ForwardIterator
> destroy_n(_ForwardIterator __first, _Size __count)
> {
> return std::_Destroy_n(__first, __count);
> }
>
>
>
>}
># 61 "/usr/include/c++/8/bits/stl_tempbuf.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 83 "/usr/include/c++/8/bits/stl_tempbuf.h" 3
> template<typename _Tp>
> pair<_Tp*, ptrdiff_t>
> get_temporary_buffer(ptrdiff_t __len) noexcept
> {
> const ptrdiff_t __max =
> __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
> if (__len > __max)
> __len = __max;
>
> while (__len > 0)
> {
> _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
> std::nothrow));
> if (__tmp != 0)
> return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
> __len /= 2;
> }
> return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
> }
># 110 "/usr/include/c++/8/bits/stl_tempbuf.h" 3
> template<typename _Tp>
> inline void
> return_temporary_buffer(_Tp* __p)
> { ::operator delete(__p, std::nothrow); }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> class _Temporary_buffer
> {
>
> 
>
> public:
> typedef _Tp value_type;
> typedef value_type* pointer;
> typedef pointer iterator;
> typedef ptrdiff_t size_type;
>
> protected:
> size_type _M_original_len;
> size_type _M_len;
> pointer _M_buffer;
>
> public:
>
> size_type
> size() const
> { return _M_len; }
>
>
> size_type
> requested_size() const
> { return _M_original_len; }
>
>
> iterator
> begin()
> { return _M_buffer; }
>
>
> iterator
> end()
> { return _M_buffer + _M_len; }
>
>
>
>
>
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
>
> ~_Temporary_buffer()
> {
> std::_Destroy(_M_buffer, _M_buffer + _M_len);
> std::return_temporary_buffer(_M_buffer);
> }
>
> private:
>
> _Temporary_buffer(const _Temporary_buffer&);
>
> void
> operator=(const _Temporary_buffer&);
> };
>
>
> template<bool>
> struct __uninitialized_construct_buf_dispatch
> {
> template<typename _Pointer, typename _ForwardIterator>
> static void
> __ucr(_Pointer __first, _Pointer __last,
> _ForwardIterator __seed)
> {
> if(__first == __last)
> return;
>
> _Pointer __cur = __first;
> try
> {
> std::_Construct(std::__addressof(*__first),
> std::move(*__seed));
> _Pointer __prev = __cur;
> ++__cur;
> for(; __cur != __last; ++__cur, ++__prev)
> std::_Construct(std::__addressof(*__cur),
> std::move(*__prev));
> *__seed = std::move(*__prev);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_construct_buf_dispatch<true>
> {
> template<typename _Pointer, typename _ForwardIterator>
> static void
> __ucr(_Pointer, _Pointer, _ForwardIterator) { }
> };
># 229 "/usr/include/c++/8/bits/stl_tempbuf.h" 3
> template<typename _Pointer, typename _ForwardIterator>
> inline void
> __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
> _ForwardIterator __seed)
> {
> typedef typename std::iterator_traits<_Pointer>::value_type
> _ValueType;
>
> std::__uninitialized_construct_buf_dispatch<
> __has_trivial_constructor(_ValueType)>::
> __ucr(__first, __last, __seed);
> }
>
> template<typename _ForwardIterator, typename _Tp>
> _Temporary_buffer<_ForwardIterator, _Tp>::
> _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
> : _M_original_len(std::distance(__first, __last)),
> _M_len(0), _M_buffer(0)
> {
> try
> {
> std::pair<pointer, size_type> __p(std::get_temporary_buffer<
> value_type>(_M_original_len));
> _M_buffer = __p.first;
> _M_len = __p.second;
> if (_M_buffer)
> std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
> __first);
> }
> catch(...)
> {
> std::return_temporary_buffer(_M_buffer);
> _M_buffer = 0;
> _M_len = 0;
> throw;
> }
> }
>
>
>}
># 63 "/usr/include/c++/8/bits/stl_algo.h" 2 3
>
>
>
># 1 "/usr/include/c++/8/bits/uniform_int_dist.h" 1 3
># 37 "/usr/include/c++/8/bits/uniform_int_dist.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> namespace __detail
> {
>
> template<typename _Tp>
> inline bool
> _Power_of_2(_Tp __x)
> {
> return ((__x - 1) & __x) == 0;
> }
> }
>
>
>
>
>
>
> template<typename _IntType = int>
> class uniform_int_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument must be an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef uniform_int_distribution<_IntType> distribution_type;
>
> explicit
> param_type(_IntType __a = 0,
> _IntType __b = std::numeric_limits<_IntType>::max())
> : _M_a(__a), _M_b(__b)
> {
> ;
> }
>
> result_type
> a() const
> { return _M_a; }
>
> result_type
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> friend bool
> operator!=(const param_type& __p1, const param_type& __p2)
> { return !(__p1 == __p2); }
>
> private:
> _IntType _M_a;
> _IntType _M_b;
> };
>
> public:
>
>
>
> explicit
> uniform_int_distribution(_IntType __a = 0,
> _IntType __b = std::numeric_limits<_IntType>::max())
> : _M_param(__a, __b)
> { }
>
> explicit
> uniform_int_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
> result_type
> a() const
> { return _M_param.a(); }
>
> result_type
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return this->a(); }
>
>
>
>
> result_type
> max() const
> { return this->b(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, _M_param); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng)
> { this->__generate(__f, __t, __urng, _M_param); }
>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
> template<typename _UniformRandomNumberGenerator>
> void
> __generate(result_type* __f, result_type* __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { this->__generate_impl(__f, __t, __urng, __p); }
>
>
>
>
>
> friend bool
> operator==(const uniform_int_distribution& __d1,
> const uniform_int_distribution& __d2)
> { return __d1._M_param == __d2._M_param; }
>
> private:
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename uniform_int_distribution<_IntType>::result_type
> uniform_int_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> typedef typename _UniformRandomNumberGenerator::result_type
> _Gresult_type;
> typedef typename std::make_unsigned<result_type>::type __utype;
> typedef typename std::common_type<_Gresult_type, __utype>::type
> __uctype;
>
> const __uctype __urngmin = __urng.min();
> const __uctype __urngmax = __urng.max();
> const __uctype __urngrange = __urngmax - __urngmin;
> const __uctype __urange
> = __uctype(__param.b()) - __uctype(__param.a());
>
> __uctype __ret;
>
> if (__urngrange > __urange)
> {
>
> const __uctype __uerange = __urange + 1;
> const __uctype __scaling = __urngrange / __uerange;
> const __uctype __past = __uerange * __scaling;
> do
> __ret = __uctype(__urng()) - __urngmin;
> while (__ret >= __past);
> __ret /= __scaling;
> }
> else if (__urngrange < __urange)
> {
># 264 "/usr/include/c++/8/bits/uniform_int_dist.h" 3
> __uctype __tmp;
> do
> {
> const __uctype __uerngrange = __urngrange + 1;
> __tmp = (__uerngrange * operator()
> (__urng, param_type(0, __urange / __uerngrange)));
> __ret = __tmp + (__uctype(__urng()) - __urngmin);
> }
> while (__ret > __urange || __ret < __tmp);
> }
> else
> __ret = __uctype(__urng()) - __urngmin;
>
> return __ret + __param.a();
> }
>
>
> template<typename _IntType>
> template<typename _ForwardIterator,
> typename _UniformRandomNumberGenerator>
> void
> uniform_int_distribution<_IntType>::
> __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
> _UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
> typedef typename _UniformRandomNumberGenerator::result_type
> _Gresult_type;
> typedef typename std::make_unsigned<result_type>::type __utype;
> typedef typename std::common_type<_Gresult_type, __utype>::type
> __uctype;
>
> const __uctype __urngmin = __urng.min();
> const __uctype __urngmax = __urng.max();
> const __uctype __urngrange = __urngmax - __urngmin;
> const __uctype __urange
> = __uctype(__param.b()) - __uctype(__param.a());
>
> __uctype __ret;
>
> if (__urngrange > __urange)
> {
> if (__detail::_Power_of_2(__urngrange + 1)
> && __detail::_Power_of_2(__urange + 1))
> {
> while (__f != __t)
> {
> __ret = __uctype(__urng()) - __urngmin;
> *__f++ = (__ret & __urange) + __param.a();
> }
> }
> else
> {
>
> const __uctype __uerange = __urange + 1;
> const __uctype __scaling = __urngrange / __uerange;
> const __uctype __past = __uerange * __scaling;
> while (__f != __t)
> {
> do
> __ret = __uctype(__urng()) - __urngmin;
> while (__ret >= __past);
> *__f++ = __ret / __scaling + __param.a();
> }
> }
> }
> else if (__urngrange < __urange)
> {
># 348 "/usr/include/c++/8/bits/uniform_int_dist.h" 3
> __uctype __tmp;
> while (__f != __t)
> {
> do
> {
> const __uctype __uerngrange = __urngrange + 1;
> __tmp = (__uerngrange * operator()
> (__urng, param_type(0, __urange / __uerngrange)));
> __ret = __tmp + (__uctype(__urng()) - __urngmin);
> }
> while (__ret > __urange || __ret < __tmp);
> *__f++ = __ret;
> }
> }
> else
> while (__f != __t)
> *__f++ = __uctype(__urng()) - __urngmin + __param.a();
> }
>
>
>
>
>}
># 67 "/usr/include/c++/8/bits/stl_algo.h" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Iterator, typename _Compare>
> void
> __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
> _Iterator __c, _Compare __comp)
> {
> if (__comp(__a, __b))
> {
> if (__comp(__b, __c))
> std::iter_swap(__result, __b);
> else if (__comp(__a, __c))
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __a);
> }
> else if (__comp(__a, __c))
> std::iter_swap(__result, __a);
> else if (__comp(__b, __c))
> std::iter_swap(__result, __c);
> else
> std::iter_swap(__result, __b);
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && !__pred(__first))
> ++__first;
> return __first;
> }
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _RandomAccessIterator
> __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Predicate __pred, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for (; __trip_count > 0; --__trip_count)
> {
> if (__pred(__first))
> return __first;
> ++__first;
>
> if (__pred(__first))
> return __first;
> ++__first;
>
> if (__pred(__first))
> return __first;
> ++__first;
>
> if (__pred(__first))
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (__pred(__first))
> return __first;
> ++__first;
> case 2:
> if (__pred(__first))
> return __first;
> ++__first;
> case 1:
> if (__pred(__first))
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
> template<typename _Iterator, typename _Predicate>
> inline _Iterator
> __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
> {
> return __find_if(__first, __last, __pred,
> std::__iterator_category(__first));
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
> return std::__find_if(__first, __last,
> __gnu_cxx::__ops::__negate(__pred),
> std::__iterator_category(__first));
> }
>
>
>
>
> template<typename _InputIterator, typename _Predicate, typename _Distance>
> _InputIterator
> __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
> {
> for (; __len; --__len, (void) ++__first)
> if (!__pred(__first))
> break;
> return __first;
> }
># 202 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __predicate)
> {
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __p1(__first2);
> if (++__p1 == __last2)
> return std::__find_if(__first1, __last1,
> __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
>
>
> _ForwardIterator2 __p;
> _ForwardIterator1 __current = __first1;
>
> for (;;)
> {
> __first1 =
> std::__find_if(__first1, __last1,
> __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
>
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (__predicate(__current, __p))
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Integer,
> typename _UnaryPredicate>
> _ForwardIterator
> __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, _UnaryPredicate __unary_pred,
> std::forward_iterator_tag)
> {
> __first = std::__find_if(__first, __last, __unary_pred);
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && __unary_pred(__i))
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = std::__find_if(++__i, __last, __unary_pred);
> }
> return __last;
> }
>
>
>
>
>
> template<typename _RandomAccessIter, typename _Integer,
> typename _UnaryPredicate>
> _RandomAccessIter
> __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, _UnaryPredicate __unary_pred,
> std::random_access_iterator_tag)
> {
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> _DistanceType __remainder = __count;
>
> while (__remainder <= __tailSize)
> {
> __first += __remainder;
> __tailSize -= __remainder;
>
>
> _RandomAccessIter __backTrack = __first;
> while (__unary_pred(--__backTrack))
> {
> if (--__remainder == 0)
> return (__first - __count);
> }
> __remainder = __count + 1 - (__first - __backTrack);
> }
> return __last;
> }
>
> template<typename _ForwardIterator, typename _Integer,
> typename _UnaryPredicate>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count,
> _UnaryPredicate __unary_pred)
> {
> if (__count <= 0)
> return __first;
>
> if (__count == 1)
> return std::__find_if(__first, __last, __unary_pred);
>
> return std::__search_n_aux(__first, __last, __count, __unary_pred,
> std::__iterator_category(__first));
> }
>
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag,
> _BinaryPredicate __comp)
> {
> if (__first2 == __last2)
> return __last1;
>
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::__search(__first1, __last1, __first2, __last2, __comp);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BinaryPredicate>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag,
> _BinaryPredicate __comp)
> {
>
> 
>
> 
>
>
> typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
> typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
>
> _RevIterator1 __rlast1(__first1);
> _RevIterator2 __rlast2(__first2);
> _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
> _RevIterator2(__last2), __rlast2,
> __comp);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
># 423 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 471 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline _ForwardIterator1
> find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__find_end(__first1, __last1, __first2, __last2,
> std::__iterator_category(__first1),
> std::__iterator_category(__first2),
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
># 506 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return __last == std::find_if_not(__first, __last, __pred); }
># 523 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return __last == std::find_if(__first, __last, __pred); }
># 541 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return !std::none_of(__first, __last, __pred); }
># 556 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::__find_if_not(__first, __last,
> __gnu_cxx::__ops::__pred_iter(__pred));
> }
># 580 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> is_partitioned(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
> __first = std::find_if_not(__first, __last, __pred);
> if (__first == __last)
> return true;
> ++__first;
> return std::none_of(__first, __last, __pred);
> }
># 601 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> partition_point(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
>
>
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__pred(*__middle))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
>
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> __remove_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
> for (; __first != __last; ++__first)
> if (!__pred(__first))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 668 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> inline _OutputIterator
> remove_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, const _Tp& __value)
> {
>
> 
> 
>
> 
>
> ;
>
> return std::__remove_copy_if(__first, __last, __result,
> __gnu_cxx::__ops::__iter_equals_val(__value));
> }
># 700 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> inline _OutputIterator
> remove_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> return std::__remove_copy_if(__first, __last, __result,
> __gnu_cxx::__ops::__pred_iter(__pred));
> }
># 734 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
>
> template<typename _InputIterator, typename _Size, typename _OutputIterator>
> _OutputIterator
> __copy_n(_InputIterator __first, _Size __n,
> _OutputIterator __result, input_iterator_tag)
> {
> if (__n > 0)
> {
> while (true)
> {
> *__result = *__first;
> ++__result;
> if (--__n > 0)
> ++__first;
> else
> break;
> }
> }
> return __result;
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _OutputIterator>
> inline _OutputIterator
> __copy_n(_RandomAccessIterator __first, _Size __n,
> _OutputIterator __result, random_access_iterator_tag)
> { return std::copy(__first, __first + __n, __result); }
># 797 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Size, typename _OutputIterator>
> inline _OutputIterator
> copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
> {
>
> 
> 
>
>
> return std::__copy_n(__first, __n, __result,
> std::__iterator_category(__first));
> }
># 825 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator1,
> typename _OutputIterator2, typename _Predicate>
> pair<_OutputIterator1, _OutputIterator2>
> partition_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator1 __out_true, _OutputIterator2 __out_false,
> _Predicate __pred)
> {
>
> 
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__out_true = *__first;
> ++__out_true;
> }
> else
> {
> *__out_false = *__first;
> ++__out_false;
> }
>
> return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
> }
>
>
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> __remove_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
> __first = std::__find_if(__first, __last, __pred);
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> ++__first;
> for (; __first != __last; ++__first)
> if (!__pred(__first))
> {
> *__result = std::move(*__first);
> ++__result;
> }
> return __result;
> }
># 894 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> remove(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
>
> 
>
> 
>
> ;
>
> return std::__remove_if(__first, __last,
> __gnu_cxx::__ops::__iter_equals_val(__value));
> }
># 927 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> remove_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__remove_if(__first, __last,
> __gnu_cxx::__ops::__pred_iter(__pred));
> }
>
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while (++__next != __last)
> {
> if (__binary_pred(__first, __next))
> return __first;
> __first = __next;
> }
> return __last;
> }
>
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _ForwardIterator
> __unique(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> __first = std::__adjacent_find(__first, __last, __binary_pred);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!__binary_pred(__dest, __first))
> *++__dest = std::move(*__first);
> return ++__dest;
> }
># 993 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
>
> 
>
> ;
>
> return std::__unique(__first, __last,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 1023 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> inline _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
>
> 
>
>
> ;
>
> return std::__unique(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _OutputIterator
> __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
> _OutputIterator __result, _BinaryPredicate __binary_pred,
> forward_iterator_tag, output_iterator_tag)
> {
>
> 
>
>
>
> _ForwardIterator __next = __first;
> *__result = *__first;
> while (++__next != __last)
> if (!__binary_pred(__first, __next))
> {
> __first = __next;
> *++__result = *__first;
> }
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _BinaryPredicate __binary_pred,
> input_iterator_tag, output_iterator_tag)
> {
>
> 
>
>
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
> __rebound_pred
> = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
> *__result = __value;
> while (++__first != __last)
> if (!__rebound_pred(__first, __value))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _BinaryPredicate __binary_pred,
> input_iterator_tag, forward_iterator_tag)
> {
>
> 
>
>
> *__result = *__first;
> while (++__first != __last)
> if (!__binary_pred(__result, __first))
> *++__result = *__first;
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator>
> void
> __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
> while (true)
> if (__first == __last || __first == --__last)
> return;
> else
> {
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
>
>
>
>
> template<typename _RandomAccessIterator>
> void
> __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
> if (__first == __last)
> return;
> --__last;
> while (__first < __last)
> {
> std::iter_swap(__first, __last);
> ++__first;
> --__last;
> }
> }
># 1178 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline void
> reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
> {
>
> 
>
> ;
> std::__reverse(__first, __last, std::__iterator_category(__first));
> }
># 1205 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _OutputIterator>
> _OutputIterator
> reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _OutputIterator __result)
> {
>
> 
>
> 
>
> ;
>
> while (__first != __last)
> {
> --__last;
> *__result = *__last;
> ++__result;
> }
> return __result;
> }
>
>
>
>
>
> template<typename _EuclideanRingElement>
> _EuclideanRingElement
> __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
> {
> while (__n != 0)
> {
> _EuclideanRingElement __t = __m % __n;
> __m = __n;
> __n = __t;
> }
> return __m;
> }
>
> inline namespace _V2
> {
>
>
> template<typename _ForwardIterator>
> _ForwardIterator
> __rotate(_ForwardIterator __first,
> _ForwardIterator __middle,
> _ForwardIterator __last,
> forward_iterator_tag)
> {
> if (__first == __middle)
> return __last;
> else if (__last == __middle)
> return __first;
>
> _ForwardIterator __first2 = __middle;
> do
> {
> std::iter_swap(__first, __first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> }
> while (__first2 != __last);
>
> _ForwardIterator __ret = __first;
>
> __first2 = __middle;
>
> while (__first2 != __last)
> {
> std::iter_swap(__first, __first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> else if (__first2 == __last)
> __first2 = __middle;
> }
> return __ret;
> }
>
>
> template<typename _BidirectionalIterator>
> _BidirectionalIterator
> __rotate(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle)
> return __last;
> else if (__last == __middle)
> return __first;
>
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
>
> while (__first != __middle && __middle != __last)
> {
> std::iter_swap(__first, --__last);
> ++__first;
> }
>
> if (__first == __middle)
> {
> std::__reverse(__middle, __last, bidirectional_iterator_tag());
> return __last;
> }
> else
> {
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> return __first;
> }
> }
>
>
> template<typename _RandomAccessIterator>
> _RandomAccessIterator
> __rotate(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle)
> return __last;
> else if (__last == __middle)
> return __first;
>
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> _Distance __n = __last - __first;
> _Distance __k = __middle - __first;
>
> if (__k == __n - __k)
> {
> std::swap_ranges(__first, __middle, __middle);
> return __middle;
> }
>
> _RandomAccessIterator __p = __first;
> _RandomAccessIterator __ret = __first + (__last - __middle);
>
> for (;;)
> {
> if (__k < __n - __k)
> {
> if (__is_pod(_ValueType) && __k == 1)
> {
> _ValueType __t = std::move(*__p);
> std::move(__p + 1, __p + __n, __p);
> *(__p + __n - 1) = std::move(__t);
> return __ret;
> }
> _RandomAccessIterator __q = __p + __k;
> for (_Distance __i = 0; __i < __n - __k; ++ __i)
> {
> std::iter_swap(__p, __q);
> ++__p;
> ++__q;
> }
> __n %= __k;
> if (__n == 0)
> return __ret;
> std::swap(__n, __k);
> __k = __n - __k;
> }
> else
> {
> __k = __n - __k;
> if (__is_pod(_ValueType) && __k == 1)
> {
> _ValueType __t = std::move(*(__p + __n - 1));
> std::move_backward(__p, __p + __n - 1, __p + __n);
> *__p = std::move(__t);
> return __ret;
> }
> _RandomAccessIterator __q = __p + __n;
> __p = __q - __k;
> for (_Distance __i = 0; __i < __n - __k; ++ __i)
> {
> --__p;
> --__q;
> std::iter_swap(__p, __q);
> }
> __n %= __k;
> if (__n == 0)
> return __ret;
> std::swap(__n, __k);
> }
> }
> }
># 1432 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline _ForwardIterator
> rotate(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last)
> {
>
> 
>
> ;
> ;
>
> return std::__rotate(__first, __middle, __last,
> std::__iterator_category(__first));
> }
>
> }
># 1469 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _OutputIterator>
> inline _OutputIterator
> rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last, _OutputIterator __result)
> {
>
> 
> 
>
> ;
> ;
>
> return std::copy(__first, __middle,
> std::copy(__middle, __last, __result));
> }
>
>
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> __partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, forward_iterator_tag)
> {
> if (__first == __last)
> return __first;
>
> while (__pred(*__first))
> if (++__first == __last)
> return __first;
>
> _ForwardIterator __next = __first;
>
> while (++__next != __last)
> if (__pred(*__next))
> {
> std::iter_swap(__first, __next);
> ++__first;
> }
>
> return __first;
> }
>
>
> template<typename _BidirectionalIterator, typename _Predicate>
> _BidirectionalIterator
> __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _Predicate __pred, bidirectional_iterator_tag)
> {
> while (true)
> {
> while (true)
> if (__first == __last)
> return __first;
> else if (__pred(*__first))
> ++__first;
> else
> break;
> --__last;
> while (true)
> if (__first == __last)
> return __first;
> else if (!bool(__pred(*__last)))
> --__last;
> else
> break;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
># 1546 "/usr/include/c++/8/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);
>
> std::rotate(__left_split, __middle, __right_split);
> std::advance(__left_split, std::distance(__middle, __right_split));
> return __left_split;
> }
>
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
> __first = std::__find_if_not(__first, __last, __pred);
>
> if (__first == __last)
> return __first;
>
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
> return
> std::__stable_partition_adaptive(__first, __last, __pred,
> _DistanceType(__buf.requested_size()),
> __buf.begin(),
> _DistanceType(__buf.size()));
> }
># 1649 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> stable_partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__stable_partition(__first, __last,
> __gnu_cxx::__ops::__pred_iter(__pred));
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __heap_select(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last, _Compare __comp)
> {
> std::__make_heap(__first, __middle, __comp);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (__comp(__i, __first))
> std::__pop_heap(__first, __middle, __i, __comp);
> }
>
>
>
> template<typename _InputIterator, typename _RandomAccessIterator,
> typename _Compare>
> _RandomAccessIterator
> __partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _InputValueType;
> typedef iterator_traits<_RandomAccessIterator> _RItTraits;
> typedef typename _RItTraits::difference_type _DistanceType;
>
> if (__result_first == __result_last)
> return __result_last;
> _RandomAccessIterator __result_real_last = __result_first;
> while (__first != __last && __result_real_last != __result_last)
> {
> *__result_real_last = *__first;
> ++__result_real_last;
> ++__first;
> }
>
> std::__make_heap(__result_first, __result_real_last, __comp);
> while (__first != __last)
> {
> if (__comp(__first, __result_first))
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first), __comp);
> ++__first;
> }
> std::__sort_heap(__result_first, __result_real_last, __comp);
> return __result_real_last;
> }
># 1735 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator>
> inline _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last)
> {
># 1749 "/usr/include/c++/8/bits/stl_algo.h" 3
> 
> 
>
> 
>
> 
> ;
> ;
> ;
>
> return std::__partial_sort_copy(__first, __last,
> __result_first, __result_last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 1784 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator,
> typename _Compare>
> inline _RandomAccessIterator
> partial_sort_copy(_InputIterator __first, _InputIterator __last,
> _RandomAccessIterator __result_first,
> _RandomAccessIterator __result_last,
> _Compare __comp)
> {
># 1800 "/usr/include/c++/8/bits/stl_algo.h" 3
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
> ;
>
> return std::__partial_sort_copy(__first, __last,
> __result_first, __result_last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last,
> _Compare __comp)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__last);
> _RandomAccessIterator __next = __last;
> --__next;
> while (__comp(__val, __next))
> {
> *__last = std::move(*__next);
> __last = __next;
> --__next;
> }
> *__last = std::move(__val);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__first == __last) return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> if (__comp(__i, __first))
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__i);
> std::move_backward(__first, __i, __i + 1);
> *__first = std::move(__val);
> }
> else
> std::__unguarded_linear_insert(__i,
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i,
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> }
>
>
>
>
>
> enum { _S_threshold = 16 };
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first > int(_S_threshold))
> {
> std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
> std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
> __comp);
> }
> else
> std::__insertion_sort(__first, __last, __comp);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _RandomAccessIterator __pivot, _Compare __comp)
> {
> while (true)
> {
> while (__comp(__first, __pivot))
> ++__first;
> --__last;
> while (__comp(__pivot, __last))
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline _RandomAccessIterator
> __unguarded_partition_pivot(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> _RandomAccessIterator __mid = __first + (__last - __first) / 2;
> std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
> __comp);
> return std::__unguarded_partition(__first + 1, __last, __first, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> std::__heap_select(__first, __middle, __last, __comp);
> std::__sort_heap(__first, __middle, __comp);
> }
>
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit, _Compare __comp)
> {
> while (__last - __first > int(_S_threshold))
> {
> if (__depth_limit == 0)
> {
> std::__partial_sort(__first, __last, __last, __comp);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last, __comp);
> std::__introsort_loop(__cut, __last, __depth_limit, __comp);
> __last = __cut;
> }
> }
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last,
> std::__lg(__last - __first) * 2,
> __comp);
> std::__final_insertion_sort(__first, __last, __comp);
> }
> }
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Size __depth_limit,
> _Compare __comp)
> {
> while (__last - __first > 3)
> {
> if (__depth_limit == 0)
> {
> std::__heap_select(__first, __nth + 1, __last, __comp);
>
> std::iter_swap(__first, __nth);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last, __comp);
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
># 2021 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> inline _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
>
> 
> 
>
> 
> ;
>
> return std::__lower_bound(__first, __last, __val,
> __gnu_cxx::__ops::__iter_comp_val(__comp));
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__comp(__val, __middle))
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
># 2075 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
>
> return std::__upper_bound(__first, __last, __val,
> __gnu_cxx::__ops::__val_less_iter());
> }
># 2105 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> inline _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
>
> 
> 
>
> 
> ;
>
> return std::__upper_bound(__first, __last, __val,
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> }
>
> template<typename _ForwardIterator, typename _Tp,
> typename _CompareItTp, typename _CompareTpIt>
> pair<_ForwardIterator, _ForwardIterator>
> __equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val,
> _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
> {
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _DistanceType __len = std::distance(__first, __last);
>
> while (__len > 0)
> {
> _DistanceType __half = __len >> 1;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __half);
> if (__comp_it_val(__middle, __val))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__comp_val_it(__val, __middle))
> __len = __half;
> else
> {
> _ForwardIterator __left
> = std::__lower_bound(__first, __middle, __val, __comp_it_val);
> std::advance(__first, __len);
> _ForwardIterator __right
> = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 2176 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> 
>
> ;
> ;
>
> return std::__equal_range(__first, __last, __val,
> __gnu_cxx::__ops::__iter_less_val(),
> __gnu_cxx::__ops::__val_less_iter());
> }
># 2212 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> inline pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
>
> 
> 
>
> 
>
> 
> ;
> 
> ;
>
> return std::__equal_range(__first, __last, __val,
> __gnu_cxx::__ops::__iter_comp_val(__comp),
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> }
># 2245 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
> ;
>
> _ForwardIterator __i
> = std::__lower_bound(__first, __last, __val,
> __gnu_cxx::__ops::__iter_less_val());
> return __i != __last && !(__val < *__i);
> }
># 2278 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> bool
> binary_search(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
>
> 
> 
>
> 
> ;
> 
> ;
>
> _ForwardIterator __i
> = std::__lower_bound(__first, __last, __val,
> __gnu_cxx::__ops::__iter_comp_val(__comp));
> return __i != __last && !bool(__comp(__val, *__i));
> }
>
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> void
> __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(__first2, __first1))
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> if (__first1 != __last1)
> std::move(__first1, __last1, __result);
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3, typename _Compare>
> void
> __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result,
> _Compare __comp)
> {
> if (__first1 == __last1)
> {
> std::move_backward(__first2, __last2, __result);
> return;
> }
> else if (__first2 == __last2)
> return;
>
> --__last1;
> --__last2;
> while (true)
> {
> if (__comp(__last2, __last1))
> {
> *--__result = std::move(*__last1);
> if (__first1 == __last1)
> {
> std::move_backward(__first2, ++__last2, __result);
> return;
> }
> --__last1;
> }
> else
> {
> *--__result = std::move(*__last2);
> if (__first2 == __last2)
> return;
> --__last2;
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _Distance>
> _BidirectionalIterator1
> __rotate_adaptive(_BidirectionalIterator1 __first,
> _BidirectionalIterator1 __middle,
> _BidirectionalIterator1 __last,
> _Distance __len1, _Distance __len2,
> _BidirectionalIterator2 __buffer,
> _Distance __buffer_size)
> {
> _BidirectionalIterator2 __buffer_end;
> if (__len1 > __len2 && __len2 <= __buffer_size)
> {
> if (__len2)
> {
> __buffer_end = std::move(__middle, __last, __buffer);
> std::move_backward(__first, __middle, __last);
> return std::move(__buffer, __buffer_end, __first);
> }
> else
> return __first;
> }
> else if (__len1 <= __buffer_size)
> {
> if (__len1)
> {
> __buffer_end = std::move(__first, __middle, __buffer);
> std::move(__middle, __last, __first);
> return std::move_backward(__buffer, __buffer_end, __last);
> }
> else
> return __last;
> }
> else
> {
> std::rotate(__first, __middle, __last);
> std::advance(__first, std::distance(__middle, __last));
> return __first;
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer, typename _Compare>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__first, __middle, __buffer);
> std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
> __first, __comp);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__middle, __last, __buffer);
> std::__move_merge_adaptive_backward(__first, __middle, __buffer,
> __buffer_end, __last, __comp);
> }
> else
> {
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut
> = std::__lower_bound(__middle, __last, *__first_cut,
> __gnu_cxx::__ops::__iter_comp_val(__comp));
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut
> = std::__upper_bound(__first, __middle, *__second_cut,
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> __len11 = std::distance(__first, __first_cut);
> }
>
> _BidirectionalIterator __new_middle
> = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
> __len1 - __len11, __len22, __buffer,
> __buffer_size);
> std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
> __len22, __buffer, __buffer_size, __comp);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer,
> __buffer_size, __comp);
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Compare>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Compare __comp)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
>
> if (__len1 + __len2 == 2)
> {
> if (__comp(__middle, __first))
> std::iter_swap(__first, __middle);
> return;
> }
>
> _BidirectionalIterator __first_cut = __first;
> _BidirectionalIterator __second_cut = __middle;
> _Distance __len11 = 0;
> _Distance __len22 = 0;
> if (__len1 > __len2)
> {
> __len11 = __len1 / 2;
> std::advance(__first_cut, __len11);
> __second_cut
> = std::__lower_bound(__middle, __last, *__first_cut,
> __gnu_cxx::__ops::__iter_comp_val(__comp));
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut
> = std::__upper_bound(__first, __middle, *__second_cut,
> __gnu_cxx::__ops::__val_comp_iter(__comp));
> __len11 = std::distance(__first, __first_cut);
> }
>
> std::rotate(__first_cut, __middle, __second_cut);
> _BidirectionalIterator __new_middle = __first_cut;
> std::advance(__new_middle, std::distance(__middle, __second_cut));
> std::__merge_without_buffer(__first, __first_cut, __new_middle,
> __len11, __len22, __comp);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22, __comp);
> }
>
> template<typename _BidirectionalIterator, typename _Compare>
> void
> __inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
> if (__first == __middle || __middle == __last)
> return;
>
> const _DistanceType __len1 = std::distance(__first, __middle);
> const _DistanceType __len2 = std::distance(__middle, __last);
>
> typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
> _TmpBuf __buf(__first, __last);
>
> if (__buf.begin() == 0)
> std::__merge_without_buffer
> (__first, __middle, __last, __len1, __len2, __comp);
> else
> std::__merge_adaptive
> (__first, __middle, __last, __len1, __len2, __buf.begin(),
> _DistanceType(__buf.size()), __comp);
> }
># 2572 "/usr/include/c++/8/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());
> }
># 2613 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> inline void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
> ;
>
> std::__inplace_merge(__first, __middle, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
>
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _Compare>
> _OutputIterator
> __move_merge(_InputIterator __first1, _InputIterator __last1,
> _InputIterator __first2, _InputIterator __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(__first2, __first1))
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> return std::move(__first2, __last2, std::move(__first1, __last1, __result))
>
> ;
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance, typename _Compare>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result, _Distance __step_size,
> _Compare __comp)
> {
> const _Distance __two_step = 2 * __step_size;
>
> while (__last - __first >= __two_step)
> {
> __result = std::__move_merge(__first, __first + __step_size,
> __first + __step_size,
> __first + __two_step,
> __result, __comp);
> __first += __two_step;
> }
> __step_size = std::min(_Distance(__last - __first), __step_size);
>
> std::__move_merge(__first, __first + __step_size,
> __first + __step_size, __last, __result, __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Compare>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size, _Compare __comp)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size, __comp);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last, __comp);
> }
>
> enum { _S_chunk_size = 7 };
>
> template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _Distance;
>
> const _Distance __len = __last - __first;
> const _Pointer __buffer_last = __buffer + __len;
>
> _Distance __step_size = _S_chunk_size;
> std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer,
> __step_size, __comp);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first,
> __step_size, __comp);
> __step_size *= 2;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance, typename _Compare>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size,
> _Compare __comp)
> {
> const _Distance __len = (__last - __first + 1) / 2;
> const _RandomAccessIterator __middle = __first + __len;
> if (__len > __buffer_size)
> {
> std::__stable_sort_adaptive(__first, __middle, __buffer,
> __buffer_size, __comp);
> std::__stable_sort_adaptive(__middle, __last, __buffer,
> __buffer_size, __comp);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
> std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size,
> __comp);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last, __comp);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle, __comp);
> std::__inplace_stable_sort(__middle, __last, __comp);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle,
> __comp);
> }
># 2785 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> __includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(__first2, __first1))
> return false;
> else if (__comp(__first1, __first2))
> ++__first1;
> else
> {
> ++__first1;
> ++__first2;
> }
>
> return __first2 == __last2;
> }
># 2824 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> inline bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
>
> 
> 
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__includes(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 2868 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> inline bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _Compare __comp)
> {
>
> 
> 
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__includes(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
># 2903 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> __next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(__i, __ii))
> {
> _BidirectionalIterator __j = __last;
> while (!__comp(__i, --__j))
> {}
> std::iter_swap(__i, __j);
> std::__reverse(__ii, __last,
> std::__iterator_category(__first));
> return true;
> }
> if (__i == __first)
> {
> std::__reverse(__first, __last,
> std::__iterator_category(__first));
> return false;
> }
> }
> }
># 2952 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> return std::__next_permutation
> (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
> }
># 2984 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> inline bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
>
> return std::__next_permutation
> (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _BidirectionalIterator, typename _Compare>
> bool
> __prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (__comp(__ii, __i))
> {
> _BidirectionalIterator __j = __last;
> while (!__comp(--__j, __i))
> {}
> std::iter_swap(__i, __j);
> std::__reverse(__ii, __last,
> std::__iterator_category(__first));
> return true;
> }
> if (__i == __first)
> {
> std::__reverse(__first, __last,
> std::__iterator_category(__first));
> return false;
> }
> }
> }
># 3052 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> return std::__prev_permutation(__first, __last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 3084 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> inline bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
>
> return std::__prev_permutation(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
>
>
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate, typename _Tp>
> _OutputIterator
> __replace_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _Predicate __pred, const _Tp& __new_value)
> {
> for (; __first != __last; ++__first, (void)++__result)
> if (__pred(__first))
> *__result = __new_value;
> else
> *__result = *__first;
> return __result;
> }
># 3134 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> inline _OutputIterator
> replace_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> return std::__replace_copy_if(__first, __last, __result,
> __gnu_cxx::__ops::__iter_equals_val(__old_value),
> __new_value);
> }
># 3168 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate, typename _Tp>
> inline _OutputIterator
> replace_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> return std::__replace_copy_if(__first, __last, __result,
> __gnu_cxx::__ops::__pred_iter(__pred),
> __new_value);
> }
>
> template<typename _InputIterator, typename _Predicate>
> typename iterator_traits<_InputIterator>::difference_type
> __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> {
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for (; __first != __last; ++__first)
> if (__pred(__first))
> ++__n;
> return __n;
> }
># 3207 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline bool
> is_sorted(_ForwardIterator __first, _ForwardIterator __last)
> { return std::is_sorted_until(__first, __last) == __last; }
># 3221 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> inline bool
> is_sorted(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> { return std::is_sorted_until(__first, __last, __comp) == __last; }
>
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
> if (__first == __last)
> return __last;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, (void)++__next)
> if (__comp(__next, __first))
> return __next;
> return __next;
> }
># 3250 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline _ForwardIterator
> is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> ;
>
> return std::__is_sorted_until(__first, __last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 3274 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> inline _ForwardIterator
> is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
> ;
>
> return std::__is_sorted_until(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
># 3299 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _Tp>
> constexpr
> inline pair<const _Tp&, const _Tp&>
> minmax(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
> : pair<const _Tp&, const _Tp&>(__a, __b);
> }
># 3320 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _Tp, typename _Compare>
> constexpr
> inline pair<const _Tp&, const _Tp&>
> minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
> return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
> : pair<const _Tp&, const _Tp&>(__a, __b);
> }
>
> template<typename _ForwardIterator, typename _Compare>
> constexpr
> pair<_ForwardIterator, _ForwardIterator>
> __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
> _ForwardIterator __next = __first;
> if (__first == __last
> || ++__next == __last)
> return std::make_pair(__first, __first);
>
> _ForwardIterator __min{}, __max{};
> if (__comp(__next, __first))
> {
> __min = __next;
> __max = __first;
> }
> else
> {
> __min = __first;
> __max = __next;
> }
>
> __first = __next;
> ++__first;
>
> while (__first != __last)
> {
> __next = __first;
> if (++__next == __last)
> {
> if (__comp(__first, __min))
> __min = __first;
> else if (!__comp(__first, __max))
> __max = __first;
> break;
> }
>
> if (__comp(__next, __first))
> {
> if (__comp(__next, __min))
> __min = __next;
> if (!__comp(__first, __max))
> __max = __first;
> }
> else
> {
> if (__comp(__first, __min))
> __min = __first;
> if (!__comp(__next, __max))
> __max = __next;
> }
>
> __first = __next;
> ++__first;
> }
>
> return std::make_pair(__min, __max);
> }
># 3400 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> constexpr
> inline pair<_ForwardIterator, _ForwardIterator>
> minmax_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> ;
>
> return std::__minmax_element(__first, __last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 3428 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> constexpr
> inline pair<_ForwardIterator, _ForwardIterator>
> minmax_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
> ;
>
> return std::__minmax_element(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
>
> template<typename _Tp>
> constexpr
> inline _Tp
> min(initializer_list<_Tp> __l)
> { return *std::min_element(__l.begin(), __l.end()); }
>
> template<typename _Tp, typename _Compare>
> constexpr
> inline _Tp
> min(initializer_list<_Tp> __l, _Compare __comp)
> { return *std::min_element(__l.begin(), __l.end(), __comp); }
>
> template<typename _Tp>
> constexpr
> inline _Tp
> max(initializer_list<_Tp> __l)
> { return *std::max_element(__l.begin(), __l.end()); }
>
> template<typename _Tp, typename _Compare>
> constexpr
> inline _Tp
> max(initializer_list<_Tp> __l, _Compare __comp)
> { return *std::max_element(__l.begin(), __l.end(), __comp); }
>
> template<typename _Tp>
> constexpr
> inline pair<_Tp, _Tp>
> minmax(initializer_list<_Tp> __l)
> {
> pair<const _Tp*, const _Tp*> __p =
> std::minmax_element(__l.begin(), __l.end());
> return std::make_pair(*__p.first, *__p.second);
> }
>
> template<typename _Tp, typename _Compare>
> constexpr
> inline pair<_Tp, _Tp>
> minmax(initializer_list<_Tp> __l, _Compare __comp)
> {
> pair<const _Tp*, const _Tp*> __p =
> std::minmax_element(__l.begin(), __l.end(), __comp);
> return std::make_pair(*__p.first, *__p.second);
> }
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> bool
> __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _BinaryPredicate __pred)
> {
>
>
> for (; __first1 != __last1; ++__first1, (void)++__first2)
> if (!__pred(__first1, __first2))
> break;
>
> if (__first1 == __last1)
> return true;
>
>
>
> _ForwardIterator2 __last2 = __first2;
> std::advance(__last2, std::distance(__first1, __last1));
> for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
> {
> if (__scan != std::__find_if(__first1, __scan,
> __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
> continue;
>
> auto __matches
> = std::__count_if(__first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
> if (0 == __matches ||
> std::__count_if(__scan, __last1,
> __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
> != __matches)
> return false;
> }
> return true;
> }
># 3540 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__is_permutation(__first1, __last1, __first2,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 3571 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _BinaryPredicate __pred)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__is_permutation(__first1, __last1, __first2,
> __gnu_cxx::__ops::__iter_comp_iter(__pred));
> }
>
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> bool
> __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __pred)
> {
> using _Cat1
> = typename iterator_traits<_ForwardIterator1>::iterator_category;
> using _Cat2
> = typename iterator_traits<_ForwardIterator2>::iterator_category;
> using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
> using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
> constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
> if (__ra_iters)
> {
> auto __d1 = std::distance(__first1, __last1);
> auto __d2 = std::distance(__first2, __last2);
> if (__d1 != __d2)
> return false;
> }
>
>
>
> for (; __first1 != __last1 && __first2 != __last2;
> ++__first1, (void)++__first2)
> if (!__pred(__first1, __first2))
> break;
>
> if (__ra_iters)
> {
> if (__first1 == __last1)
> return true;
> }
> else
> {
> auto __d1 = std::distance(__first1, __last1);
> auto __d2 = std::distance(__first2, __last2);
> if (__d1 == 0 && __d2 == 0)
> return true;
> if (__d1 != __d2)
> return false;
> }
>
> for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
> {
> if (__scan != std::__find_if(__first1, __scan,
> __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
> continue;
>
> auto __matches = std::__count_if(__first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
> if (0 == __matches
> || std::__count_if(__scan, __last1,
> __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
> != __matches)
> return false;
> }
> return true;
> }
># 3664 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
> ;
> ;
>
> return
> std::__is_permutation(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 3691 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __pred)
> {
> ;
> ;
>
> return std::__is_permutation(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__pred));
> }
># 3717 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _Tp>
> constexpr const _Tp&
> clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
> {
> ;
> return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
> }
># 3735 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _Tp, typename _Compare>
> constexpr const _Tp&
> clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
> {
> ;
> return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
> }
># 3767 "/usr/include/c++/8/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);
> }
># 3789 "/usr/include/c++/8/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)));
> }
>
>
>
>
>
># 3874 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Function>
> _Function
> for_each(_InputIterator __first, _InputIterator __last, _Function __f)
> {
>
> 
> ;
> for (; __first != __last; ++__first)
> __f(*__first);
> return __f;
> }
># 3895 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
> return std::__find_if(__first, __last,
> __gnu_cxx::__ops::__iter_equals_val(__val));
> }
># 3919 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
>
> return std::__find_if(__first, __last,
> __gnu_cxx::__ops::__pred_iter(__pred));
> }
># 3950 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for (; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (*__first1 == *__iter)
> return __first1;
> return __last1;
> }
># 3990 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _InputIterator
> find_first_of(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2, _ForwardIterator __last2,
> _BinaryPredicate __comp)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> for (; __first1 != __last1; ++__first1)
> for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
> if (__comp(*__first1, *__iter))
> return __first1;
> return __last1;
> }
># 4022 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> return std::__adjacent_find(__first, __last,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 4047 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> inline _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
>
> ;
>
> return std::__adjacent_find(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
> }
># 4072 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> inline typename iterator_traits<_InputIterator>::difference_type
> count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
> {
>
> 
> 
>
> ;
>
> return std::__count_if(__first, __last,
> __gnu_cxx::__ops::__iter_equals_val(__value));
> }
># 4095 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline typename iterator_traits<_InputIterator>::difference_type
> count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> {
>
> 
> 
>
> ;
>
> return std::__count_if(__first, __last,
> __gnu_cxx::__ops::__pred_iter(__pred));
> }
># 4135 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__search(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_equal_to_iter());
> }
># 4174 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> inline _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> _BinaryPredicate __predicate)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
> return std::__search(__first1, __last1, __first2, __last2,
> __gnu_cxx::__ops::__iter_comp_iter(__predicate));
> }
># 4209 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> inline _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val)
> {
>
> 
> 
>
> ;
>
> return std::__search_n(__first, __last, __count,
> __gnu_cxx::__ops::__iter_equals_val(__val));
> }
># 4242 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> inline _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> return std::__search_n(__first, __last, __count,
> __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
> }
># 4267 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Searcher>
> inline _ForwardIterator
> search(_ForwardIterator __first, _ForwardIterator __last,
> const _Searcher& __searcher)
> { return __searcher(__first, __last).first; }
># 4290 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _UnaryOperation>
> _OutputIterator
> transform(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _UnaryOperation __unary_op)
> {
>
> 
> 
>
>
> ;
>
> for (; __first != __last; ++__first, (void)++__result)
> *__result = __unary_op(*__first);
> return __result;
> }
># 4327 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _BinaryOperation>
> _OutputIterator
> transform(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _OutputIterator __result,
> _BinaryOperation __binary_op)
> {
>
> 
> 
> 
>
>
> ;
>
> for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
> *__result = __binary_op(*__first1, *__first2);
> return __result;
> }
># 4360 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> replace(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (*__first == __old_value)
> *__first = __new_value;
> }
># 4392 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate, typename _Tp>
> void
> replace_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> *__first = __new_value;
> }
># 4424 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Generator>
> void
> generate(_ForwardIterator __first, _ForwardIterator __last,
> _Generator __gen)
> {
>
> 
> 
>
> ;
>
> for (; __first != __last; ++__first)
> *__first = __gen();
> }
># 4455 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _OutputIterator, typename _Size, typename _Generator>
> _OutputIterator
> generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
> {
>
> 
>
>
>
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, (void) ++__first)
> *__first = __gen();
> return __first;
> }
># 4491 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> 
>
> ;
>
> if (__first == __last)
> return __result;
> return std::__unique_copy(__first, __last, __result,
> __gnu_cxx::__ops::__iter_equal_to_iter(),
> std::__iterator_category(__first),
> std::__iterator_category(__result));
> }
># 4531 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> return std::__unique_copy(__first, __last, __result,
> __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
> std::__iterator_category(__first),
> std::__iterator_category(__result));
> }
># 4564 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> ;
>
> if (__first != __last)
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
>
> _RandomAccessIterator __j = __first
> + std::rand() % ((__i - __first) + 1);
> if (__i != __j)
> std::iter_swap(__i, __j);
> }
> }
># 4599 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
> void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
>
> _RandomNumberGenerator&& __rand)
>
>
>
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
> if (__i != __j)
> std::iter_swap(__i, __j);
> }
> }
># 4639 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__partition(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 4672 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
> ;
>
> std::__partial_sort(__first, __middle, __last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 4710 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
> ;
>
> std::__partial_sort(__first, __middle, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
># 4746 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
> ;
>
> if (__first == __last || __nth == __last)
> return;
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 4785 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
> ;
>
> if (__first == __last || __nth == __last)
> return;
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
># 4822 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
> }
># 4852 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
>
> std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> __merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(__first2, __first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2,
> std::copy(__first1, __last1, __result));
> }
># 4913 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> inline _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__merge(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 4963 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> inline _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
> 
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__merge(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
> _TmpBuf __buf(__first, __last);
>
> if (__buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last, __comp);
> else
> std::__stable_sort_adaptive(__first, __last, __buf.begin(),
> _DistanceType(__buf.size()), __comp);
> }
># 5027 "/usr/include/c++/8/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());
> }
># 5061 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> 
>
>
> ;
> ;
>
> std::__stable_sort(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator,
> typename _Compare>
> _OutputIterator
> __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(__first1, __first2))
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (__comp(__first2, __first1))
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2,
> std::copy(__first1, __last1, __result));
> }
># 5130 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> inline _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_union(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 5180 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> inline _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_union(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator,
> typename _Compare>
> _OutputIterator
> __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(__first1, __first2))
> ++__first1;
> else if (__comp(__first2, __first1))
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 5251 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> inline _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_intersection(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 5300 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> inline _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_intersection(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator,
> typename _Compare>
> _OutputIterator
> __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(__first1, __first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(__first2, __first1))
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 5373 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> inline _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_difference(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 5424 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> inline _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
>
> 
> 
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_difference(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator,
> typename _Compare>
> _OutputIterator
> __set_symmetric_difference(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _OutputIterator __result,
> _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(__first1, __first2))
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (__comp(__first2, __first1))
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2,
> std::copy(__first1, __last1, __result));
> }
># 5503 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> inline _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
>
> 
> 
> 
>
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_symmetric_difference(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 5554 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> inline _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result,
> _Compare __comp)
> {
>
> 
> 
> 
>
> 
>
> 
>
>
> 
>
>
> ;
> ;
> ;
> ;
>
> return std::__set_symmetric_difference(__first1, __last1,
> __first2, __last2, __result,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _ForwardIterator, typename _Compare>
> constexpr
> _ForwardIterator
> __min_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(__first, __result))
> __result = __first;
> return __result;
> }
># 5607 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> constexpr
> _ForwardIterator
> inline min_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> ;
>
> return std::__min_element(__first, __last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 5632 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> constexpr
> inline _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
> ;
>
> return std::__min_element(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
> template<typename _ForwardIterator, typename _Compare>
> constexpr
> _ForwardIterator
> __max_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
> if (__first == __last) return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (__comp(__result, __first))
> __result = __first;
> return __result;
> }
># 5671 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> constexpr
> inline _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> ;
>
> return std::__max_element(__first, __last,
> __gnu_cxx::__ops::__iter_less_iter());
> }
># 5696 "/usr/include/c++/8/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> constexpr
> inline _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
> ;
>
> return std::__max_element(__first, __last,
> __gnu_cxx::__ops::__iter_comp_iter(__comp));
> }
>
>
>
> template<typename _InputIterator, typename _RandomAccessIterator,
> typename _Size, typename _UniformRandomBitGenerator>
> _RandomAccessIterator
> __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
> _RandomAccessIterator __out, random_access_iterator_tag,
> _Size __n, _UniformRandomBitGenerator&& __g)
> {
> using __distrib_type = uniform_int_distribution<_Size>;
> using __param_type = typename __distrib_type::param_type;
> __distrib_type __d{};
> _Size __sample_sz = 0;
> while (__first != __last && __sample_sz != __n)
> {
> __out[__sample_sz++] = *__first;
> ++__first;
> }
> for (auto __pop_sz = __sample_sz; __first != __last;
> ++__first, (void) ++__pop_sz)
> {
> const auto __k = __d(__g, __param_type{0, __pop_sz});
> if (__k < __n)
> __out[__k] = *__first;
> }
> return __out + __sample_sz;
> }
>
>
> template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
> typename _Size, typename _UniformRandomBitGenerator>
> _OutputIterator
> __sample(_ForwardIterator __first, _ForwardIterator __last,
> forward_iterator_tag,
> _OutputIterator __out, _Cat,
> _Size __n, _UniformRandomBitGenerator&& __g)
> {
> using __distrib_type = uniform_int_distribution<_Size>;
> using __param_type = typename __distrib_type::param_type;
> using _USize = make_unsigned_t<_Size>;
> using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
> using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
>
> __distrib_type __d{};
> _Size __unsampled_sz = std::distance(__first, __last);
> __n = std::min(__n, __unsampled_sz);
>
>
>
>
> const __uc_type __urngrange = __g.max() - __g.min();
> if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
>
>
> {
> while (__n != 0 && __unsampled_sz >= 2)
> {
> const pair<_Size, _Size> __p =
> __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);
>
> --__unsampled_sz;
> if (__p.first < __n)
> {
> *__out++ = *__first;
> --__n;
> }
>
> ++__first;
>
> if (__n == 0) break;
>
> --__unsampled_sz;
> if (__p.second < __n)
> {
> *__out++ = *__first;
> --__n;
> }
>
> ++__first;
> }
> }
>
>
>
> for (; __n != 0; ++__first)
> if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
> {
> *__out++ = *__first;
> --__n;
> }
> return __out;
> }
>
>
>
>
> template<typename _PopulationIterator, typename _SampleIterator,
> typename _Distance, typename _UniformRandomBitGenerator>
> _SampleIterator
> sample(_PopulationIterator __first, _PopulationIterator __last,
> _SampleIterator __out, _Distance __n,
> _UniformRandomBitGenerator&& __g)
> {
> using __pop_cat = typename
> std::iterator_traits<_PopulationIterator>::iterator_category;
> using __samp_cat = typename
> std::iterator_traits<_SampleIterator>::iterator_category;
>
> static_assert(
> __or_<is_convertible<__pop_cat, forward_iterator_tag>,
> is_convertible<__samp_cat, random_access_iterator_tag>>::value,
> "output range must use a RandomAccessIterator when input range"
> " does not meet the ForwardIterator requirements");
>
> static_assert(is_integral<_Distance>::value,
> "sample size must be an integer type");
>
> typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
> return std::
> __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
> std::forward<_UniformRandomBitGenerator>(__g));
> }
>
>
>
>
>
>}
># 63 "/usr/include/c++/8/algorithm" 2 3
># 32 "/usr/local/include/fmt/format.h" 2 3
># 1 "/usr/include/c++/8/cassert" 1 3
># 41 "/usr/include/c++/8/cassert" 3
> 
># 42 "/usr/include/c++/8/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)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 44 "/usr/include/c++/8/cassert" 2 3
># 33 "/usr/local/include/fmt/format.h" 2 3
># 1 "/usr/include/c++/8/cmath" 1 3
># 39 "/usr/include/c++/8/cmath" 3
> 
># 40 "/usr/include/c++/8/cmath" 3
>
>
>
>
>
># 1 "/usr/include/math.h" 1 3 4
># 27 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/libc-header-start.h" 1 3 4
># 28 "/usr/include/math.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
>
>
>
>
>
># 1 "/usr/include/bits/math-vector.h" 1 3 4
># 25 "/usr/include/bits/math-vector.h" 3 4
># 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
># 26 "/usr/include/bits/math-vector.h" 2 3 4
># 41 "/usr/include/math.h" 2 3 4
># 138 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/flt-eval-method.h" 1 3 4
># 139 "/usr/include/math.h" 2 3 4
># 149 "/usr/include/math.h" 3 4
>typedef float float_t;
>typedef double double_t;
># 190 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/fp-logb.h" 1 3 4
># 191 "/usr/include/math.h" 2 3 4
># 233 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/fp-fast.h" 1 3 4
># 234 "/usr/include/math.h" 2 3 4
>
>
>
>enum
> {
> FP_INT_UPWARD =
>
> 0,
> FP_INT_DOWNWARD =
>
> 1,
> FP_INT_TOWARDZERO =
>
> 2,
> FP_INT_TONEARESTFROMZERO =
>
> 3,
> FP_INT_TONEAREST =
>
> 4,
> };
># 289 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
># 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
>extern int __fpclassify (double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern int __isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __isnan (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __iseqsig (double __x, double __y) throw ();
>
>
>extern int __issignaling (double __value) throw ()
> __attribute__ ((__const__));
># 290 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
>
>extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
>
>extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
>
>extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
>
>
> extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
>
> extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
>
>extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
>
>
>
>
>extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
>
>extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
>
>extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
>
>
>
> extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
> ;
>
>
>
>
>extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
>
>extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
>
>extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
>
>
>
>
>
> extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
>
>
>extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
>
>
>extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
>
>
> extern double log (double __x) throw (); extern double __log (double __x) throw ();
>
>
>extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
>
>
>extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
>
>
>
>
>extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
>
>
>extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
>
>
>extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
>
>
>
>
>extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
>
>
>extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
>
>
>
>
>
>
> extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
>
>
>extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
>
>
>
>extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
>
>
>
>
>extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
>
>
>
>
>
>
>extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
>
>
>extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
># 182 "/usr/include/bits/mathcalls.h" 3 4
>extern int finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
>
>
>
>extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
>
>
>
>
>
>
>extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
># 217 "/usr/include/bits/mathcalls.h" 3 4
>extern double j0 (double) throw (); extern double __j0 (double) throw ();
>extern double j1 (double) throw (); extern double __j1 (double) throw ();
>extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
>extern double y0 (double) throw (); extern double __y0 (double) throw ();
>extern double y1 (double) throw (); extern double __y1 (double) throw ();
>extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
>
>
>
>
>
>extern double erf (double) throw (); extern double __erf (double) throw ();
>extern double erfc (double) throw (); extern double __erfc (double) throw ();
>extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
>
>
>
>
>extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
>
>
>
>
>
>extern double gamma (double) throw (); extern double __gamma (double) throw ();
>
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
>
>
>
>
>
>
>extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
>
>
>extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw ();
>
>extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw ();
>
>
>
>
>extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
>
>extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
>
>
>
>extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
>
>
>
>extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
>
>
>
>extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
>
>
>
>
>extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw ();
>
>
>
>
>extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
>
>
>
>extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
>
>
>
>extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
>__extension__
>extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
>
>
>
>extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
>__extension__
>extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
>
>
>
>extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
>
>
>extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
>
>
>
>
>extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorder (double __x, double __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermag (double __x, double __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalize (double *__cx, const double *__x) throw ();
>
>
>extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw ();
>
>
>extern int setpayload (double *__x, double __payload) throw ();
>
>
>extern int setpayloadsig (double *__x, double __payload) throw ();
>
>
>
>
>
>
>
>extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
># 291 "/usr/include/math.h" 2 3 4
># 306 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
># 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
>extern int __fpclassifyf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern int __isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __iseqsigf (float __x, float __y) throw ();
>
>
>extern int __issignalingf (float __value) throw ()
> __attribute__ ((__const__));
># 307 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
>
>extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
>
>extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
>
>extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
>
>
> extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
>
> extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
>
>extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
>
>
>
>
>extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
>
>extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
>
>extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
>
>
>
> extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
> ;
>
>
>
>
>extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
>
>extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
>
>extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
>
>
>
>
>
> extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
>
>
>extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
>
>
>extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
>
>
> extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
>
>
>extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
>
>
>extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
>
>
>
>
>extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
>
>
>extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
>
>
>extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
>
>
>
>
>extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
>
>
>extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
>
>
>
>
>
>
> extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
>
>
>extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
>
>
>
>extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
>
>
>
>
>extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
>
>
>
>
>
>
>extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
># 177 "/usr/include/bits/mathcalls.h" 3 4
>extern int isinff (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>extern int finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
>
>
>
>extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
>
>
>
>
>
>
>extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
># 211 "/usr/include/bits/mathcalls.h" 3 4
>extern int isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern float j0f (float) throw (); extern float __j0f (float) throw ();
>extern float j1f (float) throw (); extern float __j1f (float) throw ();
>extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
>extern float y0f (float) throw (); extern float __y0f (float) throw ();
>extern float y1f (float) throw (); extern float __y1f (float) throw ();
>extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
>
>
>
>
>
>extern float erff (float) throw (); extern float __erff (float) throw ();
>extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
>extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
>
>
>
>
>extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
>
>
>
>
>
>extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
>
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
>
>
>
>
>
>
>extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
>
>
>extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw ();
>
>extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw ();
>
>
>
>
>extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
>
>extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
>
>
>
>extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
>
>
>
>extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
>
>
>
>extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
>
>
>
>
>extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw ();
>
>
>
>
>extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
>
>
>
>extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
>
>
>
>extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
>__extension__
>extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
>
>
>
>extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
>__extension__
>extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
>
>
>
>extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
>
>
>extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
>
>
>
>
>extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderf (float __x, float __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagf (float __x, float __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizef (float *__cx, const float *__x) throw ();
>
>
>extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw ();
>
>
>extern int setpayloadf (float *__x, float __payload) throw ();
>
>
>extern int setpayloadsigf (float *__x, float __payload) throw ();
>
>
>
>
>
>
>
>extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
># 308 "/usr/include/math.h" 2 3 4
># 349 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
># 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
>extern int __fpclassifyl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __iseqsigl (long double __x, long double __y) throw ();
>
>
>extern int __issignalingl (long double __value) throw ()
> __attribute__ ((__const__));
># 350 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
>
>extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
>
>extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
>
>extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
>
>
> extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
>
> extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
>
>extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
>
>
>
>
>extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
>
>extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
>
>extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
>
>
>
> extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ()
> ;
>
>
>
>
>extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
>
>extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
>
>extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
>
>
>
>
>
> extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
>
>
>extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
>
>
>extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
>
>
> extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
>
>
>extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
>
>
>extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
>
>
>
>
>extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
>
>
>extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
>
>
>extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
>
>
>
>
>extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
>
>
>extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
>
>
>
>
>
>
> extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
>
>
>extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
>
>
>
>extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
>
>
>
>
>extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
>
>
>
>
>
>
>extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
># 177 "/usr/include/bits/mathcalls.h" 3 4
>extern int isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>extern int finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
>
>
>
>extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
>
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
># 211 "/usr/include/bits/mathcalls.h" 3 4
>extern int isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
>extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
>extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
>extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
>extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
>extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
>
>
>
>
>
>extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
>extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
>extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
>
>
>
>
>extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
>
>
>
>
>
>extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
>
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
>
>
>
>
>
>
>extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
>
>
>extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw ();
>
>extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw ();
>
>
>
>
>extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
>
>extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
>
>
>
>extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
>
>
>
>extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
>
>
>
>extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
>
>
>
>
>extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw ();
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
>
>
>
>extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
>
>
>
>extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
>__extension__
>extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
>
>
>
>extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
>__extension__
>extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
>
>
>
>extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
>
>
>extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
>
>
>
>
>extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderl (long double __x, long double __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagl (long double __x, long double __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizel (long double *__cx, const long double *__x) throw ();
>
>
>extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw ();
>
>
>extern int setpayloadl (long double *__x, long double __payload) throw ();
>
>
>extern int setpayloadsigl (long double *__x, long double __payload) throw ();
>
>
>
>
>
>
>
>extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
># 351 "/usr/include/math.h" 2 3 4
># 389 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32 acosf32 (_Float32 __x) throw (); extern _Float32 __acosf32 (_Float32 __x) throw ();
>
>extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw ();
>
>extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw ();
>
>extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw ();
>
>
> extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw ();
>
> extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw ();
>
>extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw ();
>
>
>
>
>extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw ();
>
>extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw ();
>
>extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw ();
>
>
>
> extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw ()
> ;
>
>
>
>
>extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw ();
>
>extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw ();
>
>extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw ();
>
>
>
>
>
> extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw ();
>
>
>extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw ();
>
>
>extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw ();
>
>
> extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw ();
>
>
>extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw ();
>
>
>extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw ();
>
>
>
>
>extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw ();
>
>
>extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw ();
>
>
>extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw ();
>
>
>
>
>extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw ();
>
>
>extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw ();
>
>
>
>
>
>
> extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw ();
>
>
>extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw ();
>
>
>
>extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw ();
>
>
>
>
>extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw ();
>
>
>
>
>
>
>extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw ();
># 196 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float32 nanf32 (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float32 __nanf32 (const char *__tagb) throw () __attribute__ ((__const__));
># 217 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw ();
>extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw ();
>extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw ();
>extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw ();
>extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw ();
>extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw ();
>
>
>
>
>
>extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw ();
>extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw ();
>extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw ();
>
>
>
>
>extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw ();
># 249 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw ();
>
>
>
>
>
>
>extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw ();
>
>
>extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw ();
>
>
>
>
>
>
>extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw ();
>
>extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw ();
>
>
>
>extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw ();
>
>
>
>extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw ();
>
>
>
>extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw ();
>
>
>
>
>extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw ();
>
>
>
>
>extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw ();
>
>
>
>extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw ();
>
>
>
>extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__));
>
>
>
>extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw ();
>__extension__
>extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw ();
>
>
>
>extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw ();
>__extension__
>extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw ();
>
>
>
>extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw ();
>
>
>extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw ();
>
>
>
>
>extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderf32 (_Float32 __x, _Float32 __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagf32 (_Float32 __x, _Float32 __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw ();
>
>
>extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw ();
>
>
>extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw ();
>
>
>extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw ();
># 390 "/usr/include/math.h" 2 3 4
># 406 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw ();
>
>extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw ();
>
>extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw ();
>
>extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw ();
>
>
> extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw ();
>
> extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw ();
>
>extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw ();
>
>
>
>
>extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw ();
>
>extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw ();
>
>extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw ();
>
>
>
> extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw ()
> ;
>
>
>
>
>extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw ();
>
>extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw ();
>
>extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw ();
>
>
>
>
>
> extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw ();
>
>
>extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw ();
>
>
>extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw ();
>
>
> extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw ();
>
>
>extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw ();
>
>
>extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw ();
>
>
>
>
>extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw ();
>
>
>extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw ();
>
>
>extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw ();
>
>
>
>
>extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw ();
>
>
>extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw ();
>
>
>
>
>
>
> extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw ();
>
>
>extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw ();
>
>
>
>extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw ();
>
>
>
>
>extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw ();
>
>
>
>
>
>
>extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw ();
># 196 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float64 nanf64 (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float64 __nanf64 (const char *__tagb) throw () __attribute__ ((__const__));
># 217 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw ();
>extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw ();
>extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw ();
>extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw ();
>extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw ();
>extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw ();
>
>
>
>
>
>extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw ();
>extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw ();
>extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw ();
>
>
>
>
>extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw ();
># 249 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw ();
>
>
>
>
>
>
>extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw ();
>
>
>extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw ();
>
>
>
>
>
>
>extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw ();
>
>extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw ();
>
>
>
>extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw ();
>
>
>
>extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw ();
>
>
>
>extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw ();
>
>
>
>
>extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw ();
>
>
>
>
>extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw ();
>
>
>
>extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw ();
>
>
>
>extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__));
>
>
>
>extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw ();
>__extension__
>extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw ();
>
>
>
>extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw ();
>__extension__
>extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw ();
>
>
>
>extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw ();
>
>
>extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw ();
>
>
>
>
>extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderf64 (_Float64 __x, _Float64 __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagf64 (_Float64 __x, _Float64 __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw ();
>
>
>extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw ();
>
>
>extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw ();
>
>
>extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw ();
># 407 "/usr/include/math.h" 2 3 4
># 420 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
># 21 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
>extern int __fpclassifyf128 (_Float128 __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitf128 (_Float128 __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern int __isinff128 (_Float128 __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef128 (_Float128 __value) throw () __attribute__ ((__const__));
>
>
>extern int __isnanf128 (_Float128 __value) throw () __attribute__ ((__const__));
>
>
>extern int __iseqsigf128 (_Float128 __x, _Float128 __y) throw ();
>
>
>extern int __issignalingf128 (_Float128 __value) throw ()
> __attribute__ ((__const__));
># 421 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float128 acosf128 (_Float128 __x) throw (); extern _Float128 __acosf128 (_Float128 __x) throw ();
>
>extern _Float128 asinf128 (_Float128 __x) throw (); extern _Float128 __asinf128 (_Float128 __x) throw ();
>
>extern _Float128 atanf128 (_Float128 __x) throw (); extern _Float128 __atanf128 (_Float128 __x) throw ();
>
>extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) throw ();
>
>
> extern _Float128 cosf128 (_Float128 __x) throw (); extern _Float128 __cosf128 (_Float128 __x) throw ();
>
> extern _Float128 sinf128 (_Float128 __x) throw (); extern _Float128 __sinf128 (_Float128 __x) throw ();
>
>extern _Float128 tanf128 (_Float128 __x) throw (); extern _Float128 __tanf128 (_Float128 __x) throw ();
>
>
>
>
>extern _Float128 coshf128 (_Float128 __x) throw (); extern _Float128 __coshf128 (_Float128 __x) throw ();
>
>extern _Float128 sinhf128 (_Float128 __x) throw (); extern _Float128 __sinhf128 (_Float128 __x) throw ();
>
>extern _Float128 tanhf128 (_Float128 __x) throw (); extern _Float128 __tanhf128 (_Float128 __x) throw ();
>
>
>
> extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw (); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw ()
> ;
>
>
>
>
>extern _Float128 acoshf128 (_Float128 __x) throw (); extern _Float128 __acoshf128 (_Float128 __x) throw ();
>
>extern _Float128 asinhf128 (_Float128 __x) throw (); extern _Float128 __asinhf128 (_Float128 __x) throw ();
>
>extern _Float128 atanhf128 (_Float128 __x) throw (); extern _Float128 __atanhf128 (_Float128 __x) throw ();
>
>
>
>
>
> extern _Float128 expf128 (_Float128 __x) throw (); extern _Float128 __expf128 (_Float128 __x) throw ();
>
>
>extern _Float128 frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) throw ();
>
>
>extern _Float128 ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) throw ();
>
>
> extern _Float128 logf128 (_Float128 __x) throw (); extern _Float128 __logf128 (_Float128 __x) throw ();
>
>
>extern _Float128 log10f128 (_Float128 __x) throw (); extern _Float128 __log10f128 (_Float128 __x) throw ();
>
>
>extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) throw (); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern _Float128 exp10f128 (_Float128 __x) throw (); extern _Float128 __exp10f128 (_Float128 __x) throw ();
>
>
>
>
>extern _Float128 expm1f128 (_Float128 __x) throw (); extern _Float128 __expm1f128 (_Float128 __x) throw ();
>
>
>extern _Float128 log1pf128 (_Float128 __x) throw (); extern _Float128 __log1pf128 (_Float128 __x) throw ();
>
>
>extern _Float128 logbf128 (_Float128 __x) throw (); extern _Float128 __logbf128 (_Float128 __x) throw ();
>
>
>
>
>extern _Float128 exp2f128 (_Float128 __x) throw (); extern _Float128 __exp2f128 (_Float128 __x) throw ();
>
>
>extern _Float128 log2f128 (_Float128 __x) throw (); extern _Float128 __log2f128 (_Float128 __x) throw ();
>
>
>
>
>
>
> extern _Float128 powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) throw ();
>
>
>extern _Float128 sqrtf128 (_Float128 __x) throw (); extern _Float128 __sqrtf128 (_Float128 __x) throw ();
>
>
>
>extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) throw ();
>
>
>
>
>extern _Float128 cbrtf128 (_Float128 __x) throw (); extern _Float128 __cbrtf128 (_Float128 __x) throw ();
>
>
>
>
>
>
>extern _Float128 ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float128 fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float128 floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) throw () __attribute__ ((__const__));
>
>
>extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) throw ();
># 196 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float128 nanf128 (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float128 __nanf128 (const char *__tagb) throw () __attribute__ ((__const__));
># 217 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float128 j0f128 (_Float128) throw (); extern _Float128 __j0f128 (_Float128) throw ();
>extern _Float128 j1f128 (_Float128) throw (); extern _Float128 __j1f128 (_Float128) throw ();
>extern _Float128 jnf128 (int, _Float128) throw (); extern _Float128 __jnf128 (int, _Float128) throw ();
>extern _Float128 y0f128 (_Float128) throw (); extern _Float128 __y0f128 (_Float128) throw ();
>extern _Float128 y1f128 (_Float128) throw (); extern _Float128 __y1f128 (_Float128) throw ();
>extern _Float128 ynf128 (int, _Float128) throw (); extern _Float128 __ynf128 (int, _Float128) throw ();
>
>
>
>
>
>extern _Float128 erff128 (_Float128) throw (); extern _Float128 __erff128 (_Float128) throw ();
>extern _Float128 erfcf128 (_Float128) throw (); extern _Float128 __erfcf128 (_Float128) throw ();
>extern _Float128 lgammaf128 (_Float128) throw (); extern _Float128 __lgammaf128 (_Float128) throw ();
>
>
>
>
>extern _Float128 tgammaf128 (_Float128) throw (); extern _Float128 __tgammaf128 (_Float128) throw ();
># 249 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float128 lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) throw ();
>
>
>
>
>
>
>extern _Float128 rintf128 (_Float128 __x) throw (); extern _Float128 __rintf128 (_Float128 __x) throw ();
>
>
>extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) throw ();
>
>
>
>
>
>
>extern _Float128 nextdownf128 (_Float128 __x) throw (); extern _Float128 __nextdownf128 (_Float128 __x) throw ();
>
>extern _Float128 nextupf128 (_Float128 __x) throw (); extern _Float128 __nextupf128 (_Float128 __x) throw ();
>
>
>
>extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) throw ();
>
>
>
>extern _Float128 scalbnf128 (_Float128 __x, int __n) throw (); extern _Float128 __scalbnf128 (_Float128 __x, int __n) throw ();
>
>
>
>extern int ilogbf128 (_Float128 __x) throw (); extern int __ilogbf128 (_Float128 __x) throw ();
>
>
>
>
>extern long int llogbf128 (_Float128 __x) throw (); extern long int __llogbf128 (_Float128 __x) throw ();
>
>
>
>
>extern _Float128 scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) throw ();
>
>
>
>extern _Float128 nearbyintf128 (_Float128 __x) throw (); extern _Float128 __nearbyintf128 (_Float128 __x) throw ();
>
>
>
>extern _Float128 roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) throw () __attribute__ ((__const__));
>
>
>
>extern _Float128 truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf128 (_Float128 __x) throw (); extern long int __lrintf128 (_Float128 __x) throw ();
>__extension__
>extern long long int llrintf128 (_Float128 __x) throw (); extern long long int __llrintf128 (_Float128 __x) throw ();
>
>
>
>extern long int lroundf128 (_Float128 __x) throw (); extern long int __lroundf128 (_Float128 __x) throw ();
>__extension__
>extern long long int llroundf128 (_Float128 __x) throw (); extern long long int __llroundf128 (_Float128 __x) throw ();
>
>
>
>extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) throw ();
>
>
>extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float128 fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw ();
>
>
>
>
>extern _Float128 roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
>
>
>extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderf128 (_Float128 __x, _Float128 __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagf128 (_Float128 __x, _Float128 __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) throw ();
>
>
>extern _Float128 getpayloadf128 (const _Float128 *__x) throw (); extern _Float128 __getpayloadf128 (const _Float128 *__x) throw ();
>
>
>extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) throw ();
>
>
>extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) throw ();
># 424 "/usr/include/math.h" 2 3 4
># 440 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32x acosf32x (_Float32x __x) throw (); extern _Float32x __acosf32x (_Float32x __x) throw ();
>
>extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw ();
>
>extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw ();
>
>extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw ();
>
>
> extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw ();
>
> extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw ();
>
>extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw ();
>
>
>
>
>extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw ();
>
>extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw ();
>
>extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw ();
>
>
>
> extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw ()
> ;
>
>
>
>
>extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw ();
>
>extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw ();
>
>extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw ();
>
>
>
>
>
> extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw ();
>
>
>extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw ();
>
>
>extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw ();
>
>
> extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw ();
>
>
>extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw ();
>
>
>extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw ();
>
>
>
>
>extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw ();
>
>
>extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw ();
>
>
>extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw ();
>
>
>
>
>extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw ();
>
>
>extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw ();
>
>
>
>
>
>
> extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw ();
>
>
>extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw ();
>
>
>
>extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw ();
>
>
>
>
>extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw ();
>
>
>
>
>
>
>extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__));
>
>
>extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__));
>
>
>extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__));
>
>
>extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw ();
># 196 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float32x nanf32x (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float32x __nanf32x (const char *__tagb) throw () __attribute__ ((__const__));
># 217 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw ();
>extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw ();
>extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw ();
>extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw ();
>extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw ();
>extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw ();
>
>
>
>
>
>extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw ();
>extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw ();
>extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw ();
>
>
>
>
>extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw ();
># 249 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw ();
>
>
>
>
>
>
>extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw ();
>
>
>extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw ();
>
>
>
>
>
>
>extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw ();
>
>extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw ();
>
>
>
>extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw ();
>
>
>
>extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw ();
>
>
>
>extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw ();
>
>
>
>
>extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw ();
>
>
>
>
>extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw ();
>
>
>
>extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw ();
>
>
>
>extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__));
>
>
>
>extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw ();
>__extension__
>extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw ();
>
>
>
>extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw ();
>__extension__
>extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw ();
>
>
>
>extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw ();
>
>
>extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
>
>
>extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
>
>
>extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw ();
>
>
>
>
>extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
>
>
>extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderf32x (_Float32x __x, _Float32x __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagf32x (_Float32x __x, _Float32x __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw ();
>
>
>extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw ();
>
>
>extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw ();
>
>
>extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw ();
># 441 "/usr/include/math.h" 2 3 4
># 457 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw ();
>
>extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw ();
>
>extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw ();
>
>extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw ();
>
>
> extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw ();
>
> extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw ();
>
>extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw ();
>
>
>
>
>extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw ();
>
>extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw ();
>
>extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw ();
>
>
>
> extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw ()
> ;
>
>
>
>
>extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw ();
>
>extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw ();
>
>extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw ();
>
>
>
>
>
> extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw ();
>
>
>extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw ();
>
>
>extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw ();
>
>
> extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw ();
>
>
>extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw ();
>
>
>extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw ();
>
>
>
>
>extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw ();
>
>
>extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw ();
>
>
>extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw ();
>
>
>
>
>extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw ();
>
>
>extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw ();
>
>
>
>
>
>
> extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw ();
>
>
>extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw ();
>
>
>
>extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw ();
>
>
>
>
>extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw ();
>
>
>
>
>
>
>extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__));
>
>
>extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__));
>
>
>extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__));
>
>
>extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw ();
># 196 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float64x nanf64x (const char *__tagb) throw () __attribute__ ((__const__)); extern _Float64x __nanf64x (const char *__tagb) throw () __attribute__ ((__const__));
># 217 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw ();
>extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw ();
>extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw ();
>extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw ();
>extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw ();
>extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw ();
>
>
>
>
>
>extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw ();
>extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw ();
>extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw ();
>
>
>
>
>extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw ();
># 249 "/usr/include/bits/mathcalls.h" 3 4
>extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw ();
>
>
>
>
>
>
>extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw ();
>
>
>extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw ();
>
>
>
>
>
>
>extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw ();
>
>extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw ();
>
>
>
>extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw ();
>
>
>
>extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw ();
>
>
>
>extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw ();
>
>
>
>
>extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw ();
>
>
>
>
>extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw ();
>
>
>
>extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw ();
>
>
>
>extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__));
>
>
>
>extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw ();
>__extension__
>extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw ();
>
>
>
>extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw ();
>__extension__
>extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw ();
>
>
>
>extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw ();
>
>
>extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
>
>
>extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
>
>
>extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw ();
>
>
>
>
>extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__));
>
>
>
>extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>
>
>extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
> ;
>
>
>extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
>
>
>extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
>
>
>extern int totalorderf64x (_Float64x __x, _Float64x __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int totalordermagf64x (_Float64x __x, _Float64x __y) throw ()
> __attribute__ ((__const__));
>
>
>extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw ();
>
>
>extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw ();
>
>
>extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw ();
>
>
>extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw ();
># 458 "/usr/include/math.h" 2 3 4
># 489 "/usr/include/math.h" 3 4
>extern int signgam;
># 569 "/usr/include/math.h" 3 4
>enum
> {
> FP_NAN =
>
> 0,
> FP_INFINITE =
>
> 1,
> FP_ZERO =
>
> 2,
> FP_SUBNORMAL =
>
> 3,
> FP_NORMAL =
>
> 4
> };
># 684 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/iscanonical.h" 1 3 4
># 23 "/usr/include/bits/iscanonical.h" 3 4
>extern int __iscanonicall (long double __x)
> throw () __attribute__ ((__const__));
># 46 "/usr/include/bits/iscanonical.h" 3 4
>extern "C++" {
>inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
>inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
>inline int iscanonical (long double __val) { return __iscanonicall (__val); }
>
>inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); }
>
>}
># 685 "/usr/include/math.h" 2 3 4
># 696 "/usr/include/math.h" 3 4
>extern "C++" {
>inline int issignaling (float __val) { return __issignalingf (__val); }
>inline int issignaling (double __val) { return __issignaling (__val); }
>inline int
>issignaling (long double __val)
>{
>
>
>
> return __issignalingl (__val);
>
>}
>
>inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
>
>}
># 725 "/usr/include/math.h" 3 4
>extern "C++" {
># 754 "/usr/include/math.h" 3 4
>template <class __T> inline bool
>iszero (__T __val)
>{
> return __val == 0;
>}
>
>}
># 952 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 953 "/usr/include/math.h" 2 3 4
># 1205 "/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 (double __x, double __y) throw ()
> {
>
> return __iseqsigl (__x, __y);
>
>
>
> }
>};
>
>
>template<> struct __iseqsig_type<_Float128>
>{
> static int __call (_Float128 __x, _Float128 __y) throw ()
> {
> return __iseqsigf128 (__x, __y);
> }
>};
>
>
>template<typename _T1, typename _T2>
>inline int
>iseqsig (_T1 __x, _T2 __y) throw ()
>{
>
> typedef decltype (((__x) + (__y) + 0.0f)) _T3;
>
>
>
> return __iseqsig_type<_T3>::__call (__x, __y);
>}
>
>}
>
>
>
>
>}
># 46 "/usr/include/c++/8/cmath" 2 3
># 77 "/usr/include/c++/8/cmath" 3
>extern "C++"
>{
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> using ::acos;
>
>
> inline constexpr float
> acos(float __x)
> { return __builtin_acosf(__x); }
>
> inline constexpr long double
> acos(long double __x)
> { return __builtin_acosl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> acos(_Tp __x)
> { return __builtin_acos(__x); }
>
> using ::asin;
>
>
> inline constexpr float
> asin(float __x)
> { return __builtin_asinf(__x); }
>
> inline constexpr long double
> asin(long double __x)
> { return __builtin_asinl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> asin(_Tp __x)
> { return __builtin_asin(__x); }
>
> using ::atan;
>
>
> inline constexpr float
> atan(float __x)
> { return __builtin_atanf(__x); }
>
> inline constexpr long double
> atan(long double __x)
> { return __builtin_atanl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> atan(_Tp __x)
> { return __builtin_atan(__x); }
>
> using ::atan2;
>
>
> inline constexpr float
> atan2(float __y, float __x)
> { return __builtin_atan2f(__y, __x); }
>
> inline constexpr long double
> atan2(long double __y, long double __x)
> { return __builtin_atan2l(__y, __x); }
>
>
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> atan2(_Tp __y, _Up __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return atan2(__type(__y), __type(__x));
> }
>
> using ::ceil;
>
>
> inline constexpr float
> ceil(float __x)
> { return __builtin_ceilf(__x); }
>
> inline constexpr long double
> ceil(long double __x)
> { return __builtin_ceill(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> ceil(_Tp __x)
> { return __builtin_ceil(__x); }
>
> using ::cos;
>
>
> inline constexpr float
> cos(float __x)
> { return __builtin_cosf(__x); }
>
> inline constexpr long double
> cos(long double __x)
> { return __builtin_cosl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cos(_Tp __x)
> { return __builtin_cos(__x); }
>
> using ::cosh;
>
>
> inline constexpr float
> cosh(float __x)
> { return __builtin_coshf(__x); }
>
> inline constexpr long double
> cosh(long double __x)
> { return __builtin_coshl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cosh(_Tp __x)
> { return __builtin_cosh(__x); }
>
> using ::exp;
>
>
> inline constexpr float
> exp(float __x)
> { return __builtin_expf(__x); }
>
> inline constexpr long double
> exp(long double __x)
> { return __builtin_expl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> exp(_Tp __x)
> { return __builtin_exp(__x); }
>
> using ::fabs;
>
>
> inline constexpr float
> fabs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline constexpr long double
> fabs(long double __x)
> { return __builtin_fabsl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> fabs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::floor;
>
>
> inline constexpr float
> floor(float __x)
> { return __builtin_floorf(__x); }
>
> inline constexpr long double
> floor(long double __x)
> { return __builtin_floorl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> floor(_Tp __x)
> { return __builtin_floor(__x); }
>
> using ::fmod;
>
>
> inline constexpr float
> fmod(float __x, float __y)
> { return __builtin_fmodf(__x, __y); }
>
> inline constexpr long double
> fmod(long double __x, long double __y)
> { return __builtin_fmodl(__x, __y); }
>
>
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmod(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmod(__type(__x), __type(__y));
> }
>
> using ::frexp;
>
>
> inline float
> frexp(float __x, int* __exp)
> { return __builtin_frexpf(__x, __exp); }
>
> inline long double
> frexp(long double __x, int* __exp)
> { return __builtin_frexpl(__x, __exp); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> frexp(_Tp __x, int* __exp)
> { return __builtin_frexp(__x, __exp); }
>
> using ::ldexp;
>
>
> inline constexpr float
> ldexp(float __x, int __exp)
> { return __builtin_ldexpf(__x, __exp); }
>
> inline constexpr long double
> ldexp(long double __x, int __exp)
> { return __builtin_ldexpl(__x, __exp); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> ldexp(_Tp __x, int __exp)
> { return __builtin_ldexp(__x, __exp); }
>
> using ::log;
>
>
> inline constexpr float
> log(float __x)
> { return __builtin_logf(__x); }
>
> inline constexpr long double
> log(long double __x)
> { return __builtin_logl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log(_Tp __x)
> { return __builtin_log(__x); }
>
> using ::log10;
>
>
> inline constexpr float
> log10(float __x)
> { return __builtin_log10f(__x); }
>
> inline constexpr long double
> log10(long double __x)
> { return __builtin_log10l(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log10(_Tp __x)
> { return __builtin_log10(__x); }
>
> using ::modf;
>
>
> inline float
> modf(float __x, float* __iptr)
> { return __builtin_modff(__x, __iptr); }
>
> inline long double
> modf(long double __x, long double* __iptr)
> { return __builtin_modfl(__x, __iptr); }
>
>
> using ::pow;
>
>
> inline constexpr float
> pow(float __x, float __y)
> { return __builtin_powf(__x, __y); }
>
> inline constexpr long double
> pow(long double __x, long double __y)
> { return __builtin_powl(__x, __y); }
># 412 "/usr/include/c++/8/cmath" 3
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> pow(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return pow(__type(__x), __type(__y));
> }
>
> using ::sin;
>
>
> inline constexpr float
> sin(float __x)
> { return __builtin_sinf(__x); }
>
> inline constexpr long double
> sin(long double __x)
> { return __builtin_sinl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sin(_Tp __x)
> { return __builtin_sin(__x); }
>
> using ::sinh;
>
>
> inline constexpr float
> sinh(float __x)
> { return __builtin_sinhf(__x); }
>
> inline constexpr long double
> sinh(long double __x)
> { return __builtin_sinhl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sinh(_Tp __x)
> { return __builtin_sinh(__x); }
>
> using ::sqrt;
>
>
> inline constexpr float
> sqrt(float __x)
> { return __builtin_sqrtf(__x); }
>
> inline constexpr long double
> sqrt(long double __x)
> { return __builtin_sqrtl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sqrt(_Tp __x)
> { return __builtin_sqrt(__x); }
>
> using ::tan;
>
>
> inline constexpr float
> tan(float __x)
> { return __builtin_tanf(__x); }
>
> inline constexpr long double
> tan(long double __x)
> { return __builtin_tanl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tan(_Tp __x)
> { return __builtin_tan(__x); }
>
> using ::tanh;
>
>
> inline constexpr float
> tanh(float __x)
> { return __builtin_tanhf(__x); }
>
> inline constexpr long double
> tanh(long double __x)
> { return __builtin_tanhl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tanh(_Tp __x)
> { return __builtin_tanh(__x); }
># 536 "/usr/include/c++/8/cmath" 3
> constexpr int
> fpclassify(float __x)
> { return __builtin_fpclassify(0, 1, 4,
> 3, 2, __x); }
>
> constexpr int
> fpclassify(double __x)
> { return __builtin_fpclassify(0, 1, 4,
> 3, 2, __x); }
>
> constexpr int
> fpclassify(long double __x)
> { return __builtin_fpclassify(0, 1, 4,
> 3, 2, __x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> int>::__type
> fpclassify(_Tp __x)
> { return __x != 0 ? 4 : 2; }
>
>
>
> constexpr bool
> isfinite(float __x)
> { return __builtin_isfinite(__x); }
>
> constexpr bool
> isfinite(double __x)
> { return __builtin_isfinite(__x); }
>
> constexpr bool
> isfinite(long double __x)
> { return __builtin_isfinite(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isfinite(_Tp __x)
> { return true; }
>
>
>
> constexpr bool
> isinf(float __x)
> { return __builtin_isinf(__x); }
>
>
>
>
>
> constexpr bool
> isinf(double __x)
> { return __builtin_isinf(__x); }
>
>
> constexpr bool
> isinf(long double __x)
> { return __builtin_isinf(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isinf(_Tp __x)
> { return false; }
>
>
>
> constexpr bool
> isnan(float __x)
> { return __builtin_isnan(__x); }
>
>
>
>
>
> constexpr bool
> isnan(double __x)
> { return __builtin_isnan(__x); }
>
>
> constexpr bool
> isnan(long double __x)
> { return __builtin_isnan(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isnan(_Tp __x)
> { return false; }
>
>
>
> constexpr bool
> isnormal(float __x)
> { return __builtin_isnormal(__x); }
>
> constexpr bool
> isnormal(double __x)
> { return __builtin_isnormal(__x); }
>
> constexpr bool
> isnormal(long double __x)
> { return __builtin_isnormal(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isnormal(_Tp __x)
> { return __x != 0 ? true : false; }
>
>
>
>
> constexpr bool
> signbit(float __x)
> { return __builtin_signbit(__x); }
>
> constexpr bool
> signbit(double __x)
> { return __builtin_signbit(__x); }
>
> constexpr bool
> signbit(long double __x)
> { return __builtin_signbit(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> signbit(_Tp __x)
> { return __x < 0 ? true : false; }
>
>
>
> constexpr bool
> isgreater(float __x, float __y)
> { return __builtin_isgreater(__x, __y); }
>
> constexpr bool
> isgreater(double __x, double __y)
> { return __builtin_isgreater(__x, __y); }
>
> constexpr bool
> isgreater(long double __x, long double __y)
> { return __builtin_isgreater(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isgreater(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isgreater(__type(__x), __type(__y));
> }
>
>
>
> constexpr bool
> isgreaterequal(float __x, float __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> constexpr bool
> isgreaterequal(double __x, double __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> constexpr bool
> isgreaterequal(long double __x, long double __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isgreaterequal(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isgreaterequal(__type(__x), __type(__y));
> }
>
>
>
> constexpr bool
> isless(float __x, float __y)
> { return __builtin_isless(__x, __y); }
>
> constexpr bool
> isless(double __x, double __y)
> { return __builtin_isless(__x, __y); }
>
> constexpr bool
> isless(long double __x, long double __y)
> { return __builtin_isless(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isless(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isless(__type(__x), __type(__y));
> }
>
>
>
> constexpr bool
> islessequal(float __x, float __y)
> { return __builtin_islessequal(__x, __y); }
>
> constexpr bool
> islessequal(double __x, double __y)
> { return __builtin_islessequal(__x, __y); }
>
> constexpr bool
> islessequal(long double __x, long double __y)
> { return __builtin_islessequal(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> islessequal(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_islessequal(__type(__x), __type(__y));
> }
>
>
>
> constexpr bool
> islessgreater(float __x, float __y)
> { return __builtin_islessgreater(__x, __y); }
>
> constexpr bool
> islessgreater(double __x, double __y)
> { return __builtin_islessgreater(__x, __y); }
>
> constexpr bool
> islessgreater(long double __x, long double __y)
> { return __builtin_islessgreater(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> islessgreater(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_islessgreater(__type(__x), __type(__y));
> }
>
>
>
> constexpr bool
> isunordered(float __x, float __y)
> { return __builtin_isunordered(__x, __y); }
>
> constexpr bool
> isunordered(double __x, double __y)
> { return __builtin_isunordered(__x, __y); }
>
> constexpr bool
> isunordered(long double __x, long double __y)
> { return __builtin_isunordered(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isunordered(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isunordered(__type(__x), __type(__y));
> }
># 1065 "/usr/include/c++/8/cmath" 3
> using ::double_t;
> using ::float_t;
>
>
> using ::acosh;
> using ::acoshf;
> using ::acoshl;
>
> using ::asinh;
> using ::asinhf;
> using ::asinhl;
>
> using ::atanh;
> using ::atanhf;
> using ::atanhl;
>
> using ::cbrt;
> using ::cbrtf;
> using ::cbrtl;
>
> using ::copysign;
> using ::copysignf;
> using ::copysignl;
>
> using ::erf;
> using ::erff;
> using ::erfl;
>
> using ::erfc;
> using ::erfcf;
> using ::erfcl;
>
> using ::exp2;
> using ::exp2f;
> using ::exp2l;
>
> using ::expm1;
> using ::expm1f;
> using ::expm1l;
>
> using ::fdim;
> using ::fdimf;
> using ::fdiml;
>
> using ::fma;
> using ::fmaf;
> using ::fmal;
>
> using ::fmax;
> using ::fmaxf;
> using ::fmaxl;
>
> using ::fmin;
> using ::fminf;
> using ::fminl;
>
> using ::hypot;
> using ::hypotf;
> using ::hypotl;
>
> using ::ilogb;
> using ::ilogbf;
> using ::ilogbl;
>
> using ::lgamma;
> using ::lgammaf;
> using ::lgammal;
>
>
> using ::llrint;
> using ::llrintf;
> using ::llrintl;
>
> using ::llround;
> using ::llroundf;
> using ::llroundl;
>
>
> using ::log1p;
> using ::log1pf;
> using ::log1pl;
>
> using ::log2;
> using ::log2f;
> using ::log2l;
>
> using ::logb;
> using ::logbf;
> using ::logbl;
>
> using ::lrint;
> using ::lrintf;
> using ::lrintl;
>
> using ::lround;
> using ::lroundf;
> using ::lroundl;
>
> using ::nan;
> using ::nanf;
> using ::nanl;
>
> using ::nearbyint;
> using ::nearbyintf;
> using ::nearbyintl;
>
> using ::nextafter;
> using ::nextafterf;
> using ::nextafterl;
>
> using ::nexttoward;
> using ::nexttowardf;
> using ::nexttowardl;
>
> using ::remainder;
> using ::remainderf;
> using ::remainderl;
>
> using ::remquo;
> using ::remquof;
> using ::remquol;
>
> using ::rint;
> using ::rintf;
> using ::rintl;
>
> using ::round;
> using ::roundf;
> using ::roundl;
>
> using ::scalbln;
> using ::scalblnf;
> using ::scalblnl;
>
> using ::scalbn;
> using ::scalbnf;
> using ::scalbnl;
>
> using ::tgamma;
> using ::tgammaf;
> using ::tgammal;
>
> using ::trunc;
> using ::truncf;
> using ::truncl;
>
>
>
> constexpr float
> acosh(float __x)
> { return __builtin_acoshf(__x); }
>
> constexpr long double
> acosh(long double __x)
> { return __builtin_acoshl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> acosh(_Tp __x)
> { return __builtin_acosh(__x); }
>
>
>
> constexpr float
> asinh(float __x)
> { return __builtin_asinhf(__x); }
>
> constexpr long double
> asinh(long double __x)
> { return __builtin_asinhl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> asinh(_Tp __x)
> { return __builtin_asinh(__x); }
>
>
>
> constexpr float
> atanh(float __x)
> { return __builtin_atanhf(__x); }
>
> constexpr long double
> atanh(long double __x)
> { return __builtin_atanhl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> atanh(_Tp __x)
> { return __builtin_atanh(__x); }
>
>
>
> constexpr float
> cbrt(float __x)
> { return __builtin_cbrtf(__x); }
>
> constexpr long double
> cbrt(long double __x)
> { return __builtin_cbrtl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cbrt(_Tp __x)
> { return __builtin_cbrt(__x); }
>
>
>
> constexpr float
> copysign(float __x, float __y)
> { return __builtin_copysignf(__x, __y); }
>
> constexpr long double
> copysign(long double __x, long double __y)
> { return __builtin_copysignl(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> copysign(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return copysign(__type(__x), __type(__y));
> }
>
>
>
> constexpr float
> erf(float __x)
> { return __builtin_erff(__x); }
>
> constexpr long double
> erf(long double __x)
> { return __builtin_erfl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> erf(_Tp __x)
> { return __builtin_erf(__x); }
>
>
>
> constexpr float
> erfc(float __x)
> { return __builtin_erfcf(__x); }
>
> constexpr long double
> erfc(long double __x)
> { return __builtin_erfcl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> erfc(_Tp __x)
> { return __builtin_erfc(__x); }
>
>
>
> constexpr float
> exp2(float __x)
> { return __builtin_exp2f(__x); }
>
> constexpr long double
> exp2(long double __x)
> { return __builtin_exp2l(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> exp2(_Tp __x)
> { return __builtin_exp2(__x); }
>
>
>
> constexpr float
> expm1(float __x)
> { return __builtin_expm1f(__x); }
>
> constexpr long double
> expm1(long double __x)
> { return __builtin_expm1l(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> expm1(_Tp __x)
> { return __builtin_expm1(__x); }
>
>
>
> constexpr float
> fdim(float __x, float __y)
> { return __builtin_fdimf(__x, __y); }
>
> constexpr long double
> fdim(long double __x, long double __y)
> { return __builtin_fdiml(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fdim(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fdim(__type(__x), __type(__y));
> }
>
>
>
> constexpr float
> fma(float __x, float __y, float __z)
> { return __builtin_fmaf(__x, __y, __z); }
>
> constexpr long double
> fma(long double __x, long double __y, long double __z)
> { return __builtin_fmal(__x, __y, __z); }
>
>
>
> template<typename _Tp, typename _Up, typename _Vp>
> constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
> fma(_Tp __x, _Up __y, _Vp __z)
> {
> typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
> return fma(__type(__x), __type(__y), __type(__z));
> }
>
>
>
> constexpr float
> fmax(float __x, float __y)
> { return __builtin_fmaxf(__x, __y); }
>
> constexpr long double
> fmax(long double __x, long double __y)
> { return __builtin_fmaxl(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmax(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmax(__type(__x), __type(__y));
> }
>
>
>
> constexpr float
> fmin(float __x, float __y)
> { return __builtin_fminf(__x, __y); }
>
> constexpr long double
> fmin(long double __x, long double __y)
> { return __builtin_fminl(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmin(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmin(__type(__x), __type(__y));
> }
>
>
>
> constexpr float
> hypot(float __x, float __y)
> { return __builtin_hypotf(__x, __y); }
>
> constexpr long double
> hypot(long double __x, long double __y)
> { return __builtin_hypotl(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> hypot(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return hypot(__type(__x), __type(__y));
> }
>
>
>
> constexpr int
> ilogb(float __x)
> { return __builtin_ilogbf(__x); }
>
> constexpr int
> ilogb(long double __x)
> { return __builtin_ilogbl(__x); }
>
>
>
> template<typename _Tp>
> constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> int>::__type
> ilogb(_Tp __x)
> { return __builtin_ilogb(__x); }
>
>
>
> constexpr float
> lgamma(float __x)
> { return __builtin_lgammaf(__x); }
>
> constexpr long double
> lgamma(long double __x)
> { return __builtin_lgammal(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> lgamma(_Tp __x)
> { return __builtin_lgamma(__x); }
>
>
>
> constexpr long long
> llrint(float __x)
> { return __builtin_llrintf(__x); }
>
> constexpr long long
> llrint(long double __x)
> { return __builtin_llrintl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long long>::__type
> llrint(_Tp __x)
> { return __builtin_llrint(__x); }
>
>
>
> constexpr long long
> llround(float __x)
> { return __builtin_llroundf(__x); }
>
> constexpr long long
> llround(long double __x)
> { return __builtin_llroundl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long long>::__type
> llround(_Tp __x)
> { return __builtin_llround(__x); }
>
>
>
> constexpr float
> log1p(float __x)
> { return __builtin_log1pf(__x); }
>
> constexpr long double
> log1p(long double __x)
> { return __builtin_log1pl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log1p(_Tp __x)
> { return __builtin_log1p(__x); }
>
>
>
>
> constexpr float
> log2(float __x)
> { return __builtin_log2f(__x); }
>
> constexpr long double
> log2(long double __x)
> { return __builtin_log2l(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log2(_Tp __x)
> { return __builtin_log2(__x); }
>
>
>
> constexpr float
> logb(float __x)
> { return __builtin_logbf(__x); }
>
> constexpr long double
> logb(long double __x)
> { return __builtin_logbl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> logb(_Tp __x)
> { return __builtin_logb(__x); }
>
>
>
> constexpr long
> lrint(float __x)
> { return __builtin_lrintf(__x); }
>
> constexpr long
> lrint(long double __x)
> { return __builtin_lrintl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long>::__type
> lrint(_Tp __x)
> { return __builtin_lrint(__x); }
>
>
>
> constexpr long
> lround(float __x)
> { return __builtin_lroundf(__x); }
>
> constexpr long
> lround(long double __x)
> { return __builtin_lroundl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long>::__type
> lround(_Tp __x)
> { return __builtin_lround(__x); }
>
>
>
> constexpr float
> nearbyint(float __x)
> { return __builtin_nearbyintf(__x); }
>
> constexpr long double
> nearbyint(long double __x)
> { return __builtin_nearbyintl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> nearbyint(_Tp __x)
> { return __builtin_nearbyint(__x); }
>
>
>
> constexpr float
> nextafter(float __x, float __y)
> { return __builtin_nextafterf(__x, __y); }
>
> constexpr long double
> nextafter(long double __x, long double __y)
> { return __builtin_nextafterl(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> nextafter(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return nextafter(__type(__x), __type(__y));
> }
>
>
>
> constexpr float
> nexttoward(float __x, long double __y)
> { return __builtin_nexttowardf(__x, __y); }
>
> constexpr long double
> nexttoward(long double __x, long double __y)
> { return __builtin_nexttowardl(__x, __y); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> nexttoward(_Tp __x, long double __y)
> { return __builtin_nexttoward(__x, __y); }
>
>
>
> constexpr float
> remainder(float __x, float __y)
> { return __builtin_remainderf(__x, __y); }
>
> constexpr long double
> remainder(long double __x, long double __y)
> { return __builtin_remainderl(__x, __y); }
>
>
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> remainder(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return remainder(__type(__x), __type(__y));
> }
>
>
>
> inline float
> remquo(float __x, float __y, int* __pquo)
> { return __builtin_remquof(__x, __y, __pquo); }
>
> inline long double
> remquo(long double __x, long double __y, int* __pquo)
> { return __builtin_remquol(__x, __y, __pquo); }
>
>
>
> template<typename _Tp, typename _Up>
> inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> remquo(_Tp __x, _Up __y, int* __pquo)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return remquo(__type(__x), __type(__y), __pquo);
> }
>
>
>
> constexpr float
> rint(float __x)
> { return __builtin_rintf(__x); }
>
> constexpr long double
> rint(long double __x)
> { return __builtin_rintl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> rint(_Tp __x)
> { return __builtin_rint(__x); }
>
>
>
> constexpr float
> round(float __x)
> { return __builtin_roundf(__x); }
>
> constexpr long double
> round(long double __x)
> { return __builtin_roundl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> round(_Tp __x)
> { return __builtin_round(__x); }
>
>
>
> constexpr float
> scalbln(float __x, long __ex)
> { return __builtin_scalblnf(__x, __ex); }
>
> constexpr long double
> scalbln(long double __x, long __ex)
> { return __builtin_scalblnl(__x, __ex); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> scalbln(_Tp __x, long __ex)
> { return __builtin_scalbln(__x, __ex); }
>
>
>
> constexpr float
> scalbn(float __x, int __ex)
> { return __builtin_scalbnf(__x, __ex); }
>
> constexpr long double
> scalbn(long double __x, int __ex)
> { return __builtin_scalbnl(__x, __ex); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> scalbn(_Tp __x, int __ex)
> { return __builtin_scalbn(__x, __ex); }
>
>
>
> constexpr float
> tgamma(float __x)
> { return __builtin_tgammaf(__x); }
>
> constexpr long double
> tgamma(long double __x)
> { return __builtin_tgammal(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tgamma(_Tp __x)
> { return __builtin_tgamma(__x); }
>
>
>
> constexpr float
> trunc(float __x)
> { return __builtin_truncf(__x); }
>
> constexpr long double
> trunc(long double __x)
> { return __builtin_truncl(__x); }
>
>
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> trunc(_Tp __x)
> { return __builtin_trunc(__x); }
># 1852 "/usr/include/c++/8/cmath" 3
> template<typename _Tp>
> inline _Tp
> __hypot3(_Tp __x, _Tp __y, _Tp __z)
> {
> __x = std::abs(__x);
> __y = std::abs(__y);
> __z = std::abs(__z);
> if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
> return __a * std::sqrt((__x / __a) * (__x / __a)
> + (__y / __a) * (__y / __a)
> + (__z / __a) * (__z / __a));
> else
> return {};
> }
>
> inline float
> hypot(float __x, float __y, float __z)
> { return std::__hypot3<float>(__x, __y, __z); }
>
> inline double
> hypot(double __x, double __y, double __z)
> { return std::__hypot3<double>(__x, __y, __z); }
>
> inline long double
> hypot(long double __x, long double __y, long double __z)
> { return std::__hypot3<long double>(__x, __y, __z); }
>
> template<typename _Tp, typename _Up, typename _Vp>
> typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
> hypot(_Tp __x, _Up __y, _Vp __z)
> {
> using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
> return std::__hypot3<__type>(__x, __y, __z);
> }
>
>
>
>}
>
>
># 1 "/usr/include/c++/8/bits/specfun.h" 1 3
># 33 "/usr/include/c++/8/bits/specfun.h" 3
>#pragma GCC visibility push(default)
># 49 "/usr/include/c++/8/bits/specfun.h" 3
># 1 "/usr/include/c++/8/tr1/gamma.tcc" 1 3
># 49 "/usr/include/c++/8/tr1/gamma.tcc" 3
># 1 "/usr/include/c++/8/tr1/special_function_util.h" 1 3
># 39 "/usr/include/c++/8/tr1/special_function_util.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 50 "/usr/include/c++/8/tr1/special_function_util.h" 3
> namespace __detail
> {
>
>
>
> template<typename _Tp>
> struct __floating_point_constant
> {
> static const _Tp __value;
> };
>
>
>
> template<typename _Tp>
> struct __numeric_constants
> {
>
> static _Tp __pi() throw()
> { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
>
> static _Tp __pi_2() throw()
> { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
>
> static _Tp __pi_3() throw()
> { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
>
> static _Tp __pi_4() throw()
> { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
>
> static _Tp __1_pi() throw()
> { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
>
> static _Tp __2_sqrtpi() throw()
> { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
>
> static _Tp __sqrt2() throw()
> { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
>
> static _Tp __sqrt3() throw()
> { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
>
> static _Tp __sqrtpio2() throw()
> { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
>
> static _Tp __sqrt1_2() throw()
> { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
>
> static _Tp __lnpi() throw()
> { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
>
> static _Tp __gamma_e() throw()
> { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
>
> static _Tp __euler() throw()
> { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
> };
># 114 "/usr/include/c++/8/tr1/special_function_util.h" 3
> template<typename _Tp>
> inline bool __isnan(_Tp __x)
> { return std::isnan(__x); }
># 133 "/usr/include/c++/8/tr1/special_function_util.h" 3
> }
>
>
>
>
>
>}
># 50 "/usr/include/c++/8/tr1/gamma.tcc" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 65 "/usr/include/c++/8/tr1/gamma.tcc" 3
> namespace __detail
> {
># 76 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template <typename _Tp>
> _Tp
> __bernoulli_series(unsigned int __n)
> {
>
> static const _Tp __num[28] = {
> _Tp(1UL), -_Tp(1UL) / _Tp(2UL),
> _Tp(1UL) / _Tp(6UL), _Tp(0UL),
> -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
> _Tp(1UL) / _Tp(42UL), _Tp(0UL),
> -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
> _Tp(5UL) / _Tp(66UL), _Tp(0UL),
> -_Tp(691UL) / _Tp(2730UL), _Tp(0UL),
> _Tp(7UL) / _Tp(6UL), _Tp(0UL),
> -_Tp(3617UL) / _Tp(510UL), _Tp(0UL),
> _Tp(43867UL) / _Tp(798UL), _Tp(0UL),
> -_Tp(174611) / _Tp(330UL), _Tp(0UL),
> _Tp(854513UL) / _Tp(138UL), _Tp(0UL),
> -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
> _Tp(8553103UL) / _Tp(6UL), _Tp(0UL)
> };
>
> if (__n == 0)
> return _Tp(1);
>
> if (__n == 1)
> return -_Tp(1) / _Tp(2);
>
>
> if (__n % 2 == 1)
> return _Tp(0);
>
>
> if (__n < 28)
> return __num[__n];
>
>
> _Tp __fact = _Tp(1);
> if ((__n / 2) % 2 == 0)
> __fact *= _Tp(-1);
> for (unsigned int __k = 1; __k <= __n; ++__k)
> __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
> __fact *= _Tp(2);
>
> _Tp __sum = _Tp(0);
> for (unsigned int __i = 1; __i < 1000; ++__i)
> {
> _Tp __term = std::pow(_Tp(__i), -_Tp(__n));
> if (__term < std::numeric_limits<_Tp>::epsilon())
> break;
> __sum += __term;
> }
>
> return __fact * __sum;
> }
># 139 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> inline _Tp
> __bernoulli(int __n)
> { return __bernoulli_series<_Tp>(__n); }
># 153 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __log_gamma_bernoulli(_Tp __x)
> {
> _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
> + _Tp(0.5L) * std::log(_Tp(2)
> * __numeric_constants<_Tp>::__pi());
>
> const _Tp __xx = __x * __x;
> _Tp __help = _Tp(1) / __x;
> for ( unsigned int __i = 1; __i < 20; ++__i )
> {
> const _Tp __2i = _Tp(2 * __i);
> __help /= __2i * (__2i - _Tp(1)) * __xx;
> __lg += __bernoulli<_Tp>(2 * __i) * __help;
> }
>
> return __lg;
> }
># 181 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __log_gamma_lanczos(_Tp __x)
> {
> const _Tp __xm1 = __x - _Tp(1);
>
> static const _Tp __lanczos_cheb_7[9] = {
> _Tp( 0.99999999999980993227684700473478L),
> _Tp( 676.520368121885098567009190444019L),
> _Tp(-1259.13921672240287047156078755283L),
> _Tp( 771.3234287776530788486528258894L),
> _Tp(-176.61502916214059906584551354L),
> _Tp( 12.507343278686904814458936853L),
> _Tp(-0.13857109526572011689554707L),
> _Tp( 9.984369578019570859563e-6L),
> _Tp( 1.50563273514931155834e-7L)
> };
>
> static const _Tp __LOGROOT2PI
> = _Tp(0.9189385332046727417803297364056176L);
>
> _Tp __sum = __lanczos_cheb_7[0];
> for(unsigned int __k = 1; __k < 9; ++__k)
> __sum += __lanczos_cheb_7[__k] / (__xm1 + __k);
>
> const _Tp __term1 = (__xm1 + _Tp(0.5L))
> * std::log((__xm1 + _Tp(7.5L))
> / __numeric_constants<_Tp>::__euler());
> const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
> const _Tp __result = __term1 + (__term2 - _Tp(7));
>
> return __result;
> }
># 225 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __log_gamma(_Tp __x)
> {
> if (__x > _Tp(0.5L))
> return __log_gamma_lanczos(__x);
> else
> {
> const _Tp __sin_fact
> = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
> if (__sin_fact == _Tp(0))
> std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma")
> );
> return __numeric_constants<_Tp>::__lnpi()
> - std::log(__sin_fact)
> - __log_gamma_lanczos(_Tp(1) - __x);
> }
> }
># 252 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __log_gamma_sign(_Tp __x)
> {
> if (__x > _Tp(0))
> return _Tp(1);
> else
> {
> const _Tp __sin_fact
> = std::sin(__numeric_constants<_Tp>::__pi() * __x);
> if (__sin_fact > _Tp(0))
> return (1);
> else if (__sin_fact < _Tp(0))
> return -_Tp(1);
> else
> return _Tp(0);
> }
> }
># 283 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __log_bincoef(unsigned int __n, unsigned int __k)
> {
>
> static const _Tp __max_bincoeff
> = std::numeric_limits<_Tp>::max_exponent10
> * std::log(_Tp(10)) - _Tp(1);
>
> _Tp __coeff = ::std::lgamma(_Tp(1 + __n))
> - ::std::lgamma(_Tp(1 + __k))
> - ::std::lgamma(_Tp(1 + __n - __k));
>
>
>
>
>
> }
># 314 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __bincoef(unsigned int __n, unsigned int __k)
> {
>
> static const _Tp __max_bincoeff
> = std::numeric_limits<_Tp>::max_exponent10
> * std::log(_Tp(10)) - _Tp(1);
>
> const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
> if (__log_coeff > __max_bincoeff)
> return std::numeric_limits<_Tp>::quiet_NaN();
> else
> return std::exp(__log_coeff);
> }
># 337 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> inline _Tp
> __gamma(_Tp __x)
> { return std::exp(__log_gamma(__x)); }
># 356 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __psi_series(_Tp __x)
> {
> _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
> const unsigned int __max_iter = 100000;
> for (unsigned int __k = 1; __k < __max_iter; ++__k)
> {
> const _Tp __term = __x / (__k * (__k + __x));
> __sum += __term;
> if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
> break;
> }
> return __sum;
> }
># 386 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __psi_asymp(_Tp __x)
> {
> _Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
> const _Tp __xx = __x * __x;
> _Tp __xp = __xx;
> const unsigned int __max_iter = 100;
> for (unsigned int __k = 1; __k < __max_iter; ++__k)
> {
> const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
> __sum -= __term;
> if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
> break;
> __xp *= __xx;
> }
> return __sum;
> }
># 417 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __psi(_Tp __x)
> {
> const int __n = static_cast<int>(__x + 0.5L);
> const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
> if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__x < _Tp(0))
> {
> const _Tp __pi = __numeric_constants<_Tp>::__pi();
> return __psi(_Tp(1) - __x)
> - __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
> }
> else if (__x > _Tp(100))
> return __psi_asymp(__x);
> else
> return __psi_series(__x);
> }
># 446 "/usr/include/c++/8/tr1/gamma.tcc" 3
> template<typename _Tp>
> _Tp
> __psi(unsigned int __n, _Tp __x)
> {
> if (__x <= _Tp(0))
> std::__throw_domain_error(("Argument out of range " "in __psi")
> );
> else if (__n == 0)
> return __psi(__x);
> else
> {
> const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
>
> const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1));
>
>
>
> _Tp __result = std::exp(__ln_nfact) * __hzeta;
> if (__n % 2 == 1)
> __result = -__result;
> return __result;
> }
> }
> }
>
>
>
>
>
>
>}
># 50 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/bessel_function.tcc" 1 3
># 49 "/usr/include/c++/8/tr1/bessel_function.tcc" 3
># 1 "/usr/include/c++/8/tr1/special_function_util.h" 1 3
># 50 "/usr/include/c++/8/tr1/bessel_function.tcc" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 67 "/usr/include/c++/8/tr1/bessel_function.tcc" 3
> namespace __detail
> {
># 94 "/usr/include/c++/8/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;
> }
># 132 "/usr/include/c++/8/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;
> }
># 357 "/usr/include/c++/8/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 __mum1 = __mu - _Tp(1);
> const _Tp __mum9 = __mu - _Tp(9);
> const _Tp __mum25 = __mu - _Tp(25);
> const _Tp __mum49 = __mu - _Tp(49);
> const _Tp __xx = _Tp(64) * __x * __x;
> const _Tp __P = _Tp(1) - __mum1 * __mum9 / (_Tp(2) * __xx)
> * (_Tp(1) - __mum25 * __mum49 / (_Tp(12) * __xx));
> const _Tp __Q = __mum1 / (_Tp(8) * __x)
> * (_Tp(1) - __mum9 * __mum25 / (_Tp(6) * __xx));
>
> 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;
> }
># 413 "/usr/include/c++/8/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;
> }
># 459 "/usr/include/c++/8/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;
> }
> }
># 501 "/usr/include/c++/8/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;
> }
> }
># 538 "/usr/include/c++/8/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;
> }
># 573 "/usr/include/c++/8/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;
> }
> }
># 611 "/usr/include/c++/8/tr1/bessel_function.tcc" 3
> template <typename _Tp>
> _Tp
> __sph_neumann(unsigned int __n, _Tp __x)
> {
> if (__x < _Tp(0))
> std::__throw_domain_error(("Bad argument " "in __sph_neumann.")
> );
> else if (__isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__x == _Tp(0))
> return -std::numeric_limits<_Tp>::infinity();
> else
> {
> _Tp __j_n, __n_n, __jp_n, __np_n;
> __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
> return __n_n;
> }
> }
> }
>
>
>
>
>
>
>}
># 51 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/beta_function.tcc" 1 3
># 49 "/usr/include/c++/8/tr1/beta_function.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 65 "/usr/include/c++/8/tr1/beta_function.tcc" 3
> namespace __detail
> {
># 79 "/usr/include/c++/8/tr1/beta_function.tcc" 3
> template<typename _Tp>
> _Tp
> __beta_gamma(_Tp __x, _Tp __y)
> {
>
> _Tp __bet;
>
> if (__x > __y)
> {
> __bet = ::std::tgamma(__x)
> / ::std::tgamma(__x + __y);
> __bet *= ::std::tgamma(__y);
> }
> else
> {
> __bet = ::std::tgamma(__y)
> / ::std::tgamma(__x + __y);
> __bet *= ::std::tgamma(__x);
> }
># 111 "/usr/include/c++/8/tr1/beta_function.tcc" 3
> return __bet;
> }
># 127 "/usr/include/c++/8/tr1/beta_function.tcc" 3
> template<typename _Tp>
> _Tp
> __beta_lgamma(_Tp __x, _Tp __y)
> {
>
> _Tp __bet = ::std::lgamma(__x)
> + ::std::lgamma(__y)
> - ::std::lgamma(__x + __y);
>
>
>
>
>
> __bet = std::exp(__bet);
> return __bet;
> }
># 158 "/usr/include/c++/8/tr1/beta_function.tcc" 3
> template<typename _Tp>
> _Tp
> __beta_product(_Tp __x, _Tp __y)
> {
>
> _Tp __bet = (__x + __y) / (__x * __y);
>
> unsigned int __max_iter = 1000000;
> for (unsigned int __k = 1; __k < __max_iter; ++__k)
> {
> _Tp __term = (_Tp(1) + (__x + __y) / __k)
> / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
> __bet *= __term;
> }
>
> return __bet;
> }
># 189 "/usr/include/c++/8/tr1/beta_function.tcc" 3
> template<typename _Tp>
> inline _Tp
> __beta(_Tp __x, _Tp __y)
> {
> if (__isnan(__x) || __isnan(__y))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else
> return __beta_lgamma(__x, __y);
> }
> }
>
>
>
>
>
>
>}
># 52 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/ell_integral.tcc" 1 3
># 45 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 59 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> namespace __detail
> {
># 76 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
> {
> const _Tp __min = std::numeric_limits<_Tp>::min();
> const _Tp __max = std::numeric_limits<_Tp>::max();
> const _Tp __lolim = _Tp(5) * __min;
> const _Tp __uplim = __max / _Tp(5);
>
> if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
> std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.")
> );
> else if (__x + __y < __lolim || __x + __z < __lolim
> || __y + __z < __lolim)
> std::__throw_domain_error(("Argument too small in __ellint_rf"));
> else
> {
> const _Tp __c0 = _Tp(1) / _Tp(4);
> const _Tp __c1 = _Tp(1) / _Tp(24);
> const _Tp __c2 = _Tp(1) / _Tp(10);
> const _Tp __c3 = _Tp(3) / _Tp(44);
> const _Tp __c4 = _Tp(1) / _Tp(14);
>
> _Tp __xn = __x;
> _Tp __yn = __y;
> _Tp __zn = __z;
>
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
> _Tp __mu;
> _Tp __xndev, __yndev, __zndev;
>
> const unsigned int __max_iter = 100;
> for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
> {
> __mu = (__xn + __yn + __zn) / _Tp(3);
> __xndev = 2 - (__mu + __xn) / __mu;
> __yndev = 2 - (__mu + __yn) / __mu;
> __zndev = 2 - (__mu + __zn) / __mu;
> _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
> __epsilon = std::max(__epsilon, std::abs(__zndev));
> if (__epsilon < __errtol)
> break;
> const _Tp __xnroot = std::sqrt(__xn);
> const _Tp __ynroot = std::sqrt(__yn);
> const _Tp __znroot = std::sqrt(__zn);
> const _Tp __lambda = __xnroot * (__ynroot + __znroot)
> + __ynroot * __znroot;
> __xn = __c0 * (__xn + __lambda);
> __yn = __c0 * (__yn + __lambda);
> __zn = __c0 * (__zn + __lambda);
> }
>
> const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
> const _Tp __e3 = __xndev * __yndev * __zndev;
> const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
> + __c4 * __e3;
>
> return __s / std::sqrt(__mu);
> }
> }
># 155 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __comp_ellint_1_series(_Tp __k)
> {
>
> const _Tp __kk = __k * __k;
>
> _Tp __term = __kk / _Tp(4);
> _Tp __sum = _Tp(1) + __term;
>
> const unsigned int __max_iter = 1000;
> for (unsigned int __i = 2; __i < __max_iter; ++__i)
> {
> __term *= (2 * __i - 1) * __kk / (2 * __i);
> if (__term < std::numeric_limits<_Tp>::epsilon())
> break;
> __sum += __term;
> }
>
> return __numeric_constants<_Tp>::__pi_2() * __sum;
> }
># 193 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __comp_ellint_1(_Tp __k)
> {
>
> if (__isnan(__k))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (std::abs(__k) >= _Tp(1))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else
> return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
> }
># 221 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __ellint_1(_Tp __k, _Tp __phi)
> {
>
> if (__isnan(__k) || __isnan(__phi))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (std::abs(__k) > _Tp(1))
> std::__throw_domain_error(("Bad argument in __ellint_1."));
> else
> {
>
> const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
> + _Tp(0.5L));
> const _Tp __phi_red = __phi
> - __n * __numeric_constants<_Tp>::__pi();
>
> const _Tp __s = std::sin(__phi_red);
> const _Tp __c = std::cos(__phi_red);
>
> const _Tp __F = __s
> * __ellint_rf(__c * __c,
> _Tp(1) - __k * __k * __s * __s, _Tp(1));
>
> if (__n == 0)
> return __F;
> else
> return __F + _Tp(2) * __n * __comp_ellint_1(__k);
> }
> }
># 268 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __comp_ellint_2_series(_Tp __k)
> {
>
> const _Tp __kk = __k * __k;
>
> _Tp __term = __kk;
> _Tp __sum = __term;
>
> const unsigned int __max_iter = 1000;
> for (unsigned int __i = 2; __i < __max_iter; ++__i)
> {
> const _Tp __i2m = 2 * __i - 1;
> const _Tp __i2 = 2 * __i;
> __term *= __i2m * __i2m * __kk / (__i2 * __i2);
> if (__term < std::numeric_limits<_Tp>::epsilon())
> break;
> __sum += __term / __i2m;
> }
>
> return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
> }
># 316 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
> {
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
> const _Tp __min = std::numeric_limits<_Tp>::min();
> const _Tp __max = std::numeric_limits<_Tp>::max();
> const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
> const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));
>
> if (__x < _Tp(0) || __y < _Tp(0))
> std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.")
> );
> else if (__x + __y < __lolim || __z < __lolim)
> std::__throw_domain_error(("Argument too small " "in __ellint_rd.")
> );
> else
> {
> const _Tp __c0 = _Tp(1) / _Tp(4);
> const _Tp __c1 = _Tp(3) / _Tp(14);
> const _Tp __c2 = _Tp(1) / _Tp(6);
> const _Tp __c3 = _Tp(9) / _Tp(22);
> const _Tp __c4 = _Tp(3) / _Tp(26);
>
> _Tp __xn = __x;
> _Tp __yn = __y;
> _Tp __zn = __z;
> _Tp __sigma = _Tp(0);
> _Tp __power4 = _Tp(1);
>
> _Tp __mu;
> _Tp __xndev, __yndev, __zndev;
>
> const unsigned int __max_iter = 100;
> for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
> {
> __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
> __xndev = (__mu - __xn) / __mu;
> __yndev = (__mu - __yn) / __mu;
> __zndev = (__mu - __zn) / __mu;
> _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
> __epsilon = std::max(__epsilon, std::abs(__zndev));
> if (__epsilon < __errtol)
> break;
> _Tp __xnroot = std::sqrt(__xn);
> _Tp __ynroot = std::sqrt(__yn);
> _Tp __znroot = std::sqrt(__zn);
> _Tp __lambda = __xnroot * (__ynroot + __znroot)
> + __ynroot * __znroot;
> __sigma += __power4 / (__znroot * (__zn + __lambda));
> __power4 *= __c0;
> __xn = __c0 * (__xn + __lambda);
> __yn = __c0 * (__yn + __lambda);
> __zn = __c0 * (__zn + __lambda);
> }
>
>
> _Tp __eaa = __xndev * __yndev;
> _Tp __eb = __zndev * __zndev;
> _Tp __ec = __eaa - __eb;
> _Tp __ed = __eaa - _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 - __eaa));
>
> return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
> / (__mu * std::sqrt(__mu));
> }
> }
># 404 "/usr/include/c++/8/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);
> }
> }
># 438 "/usr/include/c++/8/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);
> }
> }
># 497 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __ellint_rc(_Tp __x, _Tp __y)
> {
> const _Tp __min = std::numeric_limits<_Tp>::min();
> const _Tp __max = std::numeric_limits<_Tp>::max();
> const _Tp __lolim = _Tp(5) * __min;
> const _Tp __uplim = __max / _Tp(5);
>
> if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
> std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.")
> );
> else
> {
> const _Tp __c0 = _Tp(1) / _Tp(4);
> const _Tp __c1 = _Tp(1) / _Tp(7);
> const _Tp __c2 = _Tp(9) / _Tp(22);
> const _Tp __c3 = _Tp(3) / _Tp(10);
> const _Tp __c4 = _Tp(3) / _Tp(8);
>
> _Tp __xn = __x;
> _Tp __yn = __y;
>
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
> _Tp __mu;
> _Tp __sn;
>
> const unsigned int __max_iter = 100;
> for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
> {
> __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
> __sn = (__yn + __mu) / __mu - _Tp(2);
> if (std::abs(__sn) < __errtol)
> break;
> const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
> + __yn;
> __xn = __c0 * (__xn + __lambda);
> __yn = __c0 * (__yn + __lambda);
> }
>
> _Tp __s = __sn * __sn
> * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));
>
> return (_Tp(1) + __s) / std::sqrt(__mu);
> }
> }
># 568 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
> {
> const _Tp __min = std::numeric_limits<_Tp>::min();
> const _Tp __max = std::numeric_limits<_Tp>::max();
> const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
> const _Tp __uplim = _Tp(0.3L)
> * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));
>
> if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
> std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.")
> );
> else if (__x + __y < __lolim || __x + __z < __lolim
> || __y + __z < __lolim || __p < __lolim)
> std::__throw_domain_error(("Argument too small " "in __ellint_rj")
> );
> else
> {
> const _Tp __c0 = _Tp(1) / _Tp(4);
> const _Tp __c1 = _Tp(3) / _Tp(14);
> const _Tp __c2 = _Tp(1) / _Tp(3);
> const _Tp __c3 = _Tp(3) / _Tp(22);
> const _Tp __c4 = _Tp(3) / _Tp(26);
>
> _Tp __xn = __x;
> _Tp __yn = __y;
> _Tp __zn = __z;
> _Tp __pn = __p;
> _Tp __sigma = _Tp(0);
> _Tp __power4 = _Tp(1);
>
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
>
> _Tp __lambda, __mu;
> _Tp __xndev, __yndev, __zndev, __pndev;
>
> const unsigned int __max_iter = 100;
> for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
> {
> __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
> __xndev = (__mu - __xn) / __mu;
> __yndev = (__mu - __yn) / __mu;
> __zndev = (__mu - __zn) / __mu;
> __pndev = (__mu - __pn) / __mu;
> _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
> __epsilon = std::max(__epsilon, std::abs(__zndev));
> __epsilon = std::max(__epsilon, std::abs(__pndev));
> if (__epsilon < __errtol)
> break;
> const _Tp __xnroot = std::sqrt(__xn);
> const _Tp __ynroot = std::sqrt(__yn);
> const _Tp __znroot = std::sqrt(__zn);
> const _Tp __lambda = __xnroot * (__ynroot + __znroot)
> + __ynroot * __znroot;
> const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
> + __xnroot * __ynroot * __znroot;
> const _Tp __alpha2 = __alpha1 * __alpha1;
> const _Tp __beta = __pn * (__pn + __lambda)
> * (__pn + __lambda);
> __sigma += __power4 * __ellint_rc(__alpha2, __beta);
> __power4 *= __c0;
> __xn = __c0 * (__xn + __lambda);
> __yn = __c0 * (__yn + __lambda);
> __zn = __c0 * (__zn + __lambda);
> __pn = __c0 * (__pn + __lambda);
> }
>
>
> _Tp __eaa = __xndev * (__yndev + __zndev) + __yndev * __zndev;
> _Tp __eb = __xndev * __yndev * __zndev;
> _Tp __ec = __pndev * __pndev;
> _Tp __e2 = __eaa - _Tp(3) * __ec;
> _Tp __e3 = __eb + _Tp(2) * __pndev * (__eaa - __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 * __eaa * (__c2 - __pndev * __c3)
> - __c2 * __pndev * __ec;
>
> return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
> / (__mu * std::sqrt(__mu));
> }
> }
># 672 "/usr/include/c++/8/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);
> }
> }
># 712 "/usr/include/c++/8/tr1/ell_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
> {
>
> if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (std::abs(__k) > _Tp(1))
> std::__throw_domain_error(("Bad argument in __ellint_3."));
> else
> {
>
> const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
> + _Tp(0.5L));
> const _Tp __phi_red = __phi
> - __n * __numeric_constants<_Tp>::__pi();
>
> const _Tp __kk = __k * __k;
> const _Tp __s = std::sin(__phi_red);
> const _Tp __ss = __s * __s;
> const _Tp __sss = __ss * __s;
> const _Tp __c = std::cos(__phi_red);
> const _Tp __cc = __c * __c;
>
> const _Tp __Pi = __s
> * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
> + __nu * __sss
> * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
> _Tp(1) - __nu * __ss) / _Tp(3);
>
> if (__n == 0)
> return __Pi;
> else
> return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
> }
> }
> }
>
>
>
>
>
>}
># 53 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/exp_integral.tcc" 1 3
># 50 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 64 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> namespace __detail
> {
> template<typename _Tp> _Tp __expint_E1(_Tp);
># 81 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_E1_series(_Tp __x)
> {
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> _Tp __term = _Tp(1);
> _Tp __esum = _Tp(0);
> _Tp __osum = _Tp(0);
> const unsigned int __max_iter = 1000;
> for (unsigned int __i = 1; __i < __max_iter; ++__i)
> {
> __term *= - __x / __i;
> if (std::abs(__term) < __eps)
> break;
> if (__term >= _Tp(0))
> __esum += __term / __i;
> else
> __osum += __term / __i;
> }
>
> return - __esum - __osum
> - __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
> }
># 118 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_E1_asymp(_Tp __x)
> {
> _Tp __term = _Tp(1);
> _Tp __esum = _Tp(1);
> _Tp __osum = _Tp(0);
> const unsigned int __max_iter = 1000;
> for (unsigned int __i = 1; __i < __max_iter; ++__i)
> {
> _Tp __prev = __term;
> __term *= - __i / __x;
> if (std::abs(__term) > std::abs(__prev))
> break;
> if (__term >= _Tp(0))
> __esum += __term;
> else
> __osum += __term;
> }
>
> return std::exp(- __x) * (__esum + __osum) / __x;
> }
># 155 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_En_series(unsigned int __n, _Tp __x)
> {
> const unsigned int __max_iter = 1000;
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const int __nm1 = __n - 1;
> _Tp __ans = (__nm1 != 0
> ? _Tp(1) / __nm1 : -std::log(__x)
> - __numeric_constants<_Tp>::__gamma_e());
> _Tp __fact = _Tp(1);
> for (int __i = 1; __i <= __max_iter; ++__i)
> {
> __fact *= -__x / _Tp(__i);
> _Tp __del;
> if ( __i != __nm1 )
> __del = -__fact / _Tp(__i - __nm1);
> else
> {
> _Tp __psi = -__numeric_constants<_Tp>::gamma_e();
> for (int __ii = 1; __ii <= __nm1; ++__ii)
> __psi += _Tp(1) / _Tp(__ii);
> __del = __fact * (__psi - std::log(__x));
> }
> __ans += __del;
> if (std::abs(__del) < __eps * std::abs(__ans))
> return __ans;
> }
> std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.")
> );
> }
># 201 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_En_cont_frac(unsigned int __n, _Tp __x)
> {
> const unsigned int __max_iter = 1000;
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __fp_min = std::numeric_limits<_Tp>::min();
> const int __nm1 = __n - 1;
> _Tp __b = __x + _Tp(__n);
> _Tp __c = _Tp(1) / __fp_min;
> _Tp __d = _Tp(1) / __b;
> _Tp __h = __d;
> for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
> {
> _Tp __a = -_Tp(__i * (__nm1 + __i));
> __b += _Tp(2);
> __d = _Tp(1) / (__a * __d + __b);
> __c = __b + __a / __c;
> const _Tp __del = __c * __d;
> __h *= __del;
> if (std::abs(__del - _Tp(1)) < __eps)
> {
> const _Tp __ans = __h * std::exp(-__x);
> return __ans;
> }
> }
> std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.")
> );
> }
># 246 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_En_recursion(unsigned int __n, _Tp __x)
> {
> _Tp __En;
> _Tp __E1 = __expint_E1(__x);
> if (__x < _Tp(__n))
> {
>
> __En = __E1;
> for (unsigned int __j = 2; __j < __n; ++__j)
> __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
> }
> else
> {
>
> __En = _Tp(1);
> const int __N = __n + 20;
> _Tp __save = _Tp(0);
> for (int __j = __N; __j > 0; --__j)
> {
> __En = (std::exp(-__x) - __j * __En) / __x;
> if (__j == __n)
> __save = __En;
> }
> _Tp __norm = __En / __E1;
> __En /= __norm;
> }
>
> return __En;
> }
># 290 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_Ei_series(_Tp __x)
> {
> _Tp __term = _Tp(1);
> _Tp __sum = _Tp(0);
> const unsigned int __max_iter = 1000;
> for (unsigned int __i = 1; __i < __max_iter; ++__i)
> {
> __term *= __x / __i;
> __sum += __term / __i;
> if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
> break;
> }
>
> return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
> }
># 321 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_Ei_asymp(_Tp __x)
> {
> _Tp __term = _Tp(1);
> _Tp __sum = _Tp(1);
> const unsigned int __max_iter = 1000;
> for (unsigned int __i = 1; __i < __max_iter; ++__i)
> {
> _Tp __prev = __term;
> __term *= __i / __x;
> if (__term < std::numeric_limits<_Tp>::epsilon())
> break;
> if (__term >= __prev)
> break;
> __sum += __term;
> }
>
> return std::exp(__x) * __sum / __x;
> }
># 354 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_Ei(_Tp __x)
> {
> if (__x < _Tp(0))
> return -__expint_E1(-__x);
> else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
> return __expint_Ei_series(__x);
> else
> return __expint_Ei_asymp(__x);
> }
># 378 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_E1(_Tp __x)
> {
> if (__x < _Tp(0))
> return -__expint_Ei(-__x);
> else if (__x < _Tp(1))
> return __expint_E1_series(__x);
> else if (__x < _Tp(100))
> return __expint_En_cont_frac(1, __x);
> else
> return __expint_E1_asymp(__x);
> }
># 408 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_asymp(unsigned int __n, _Tp __x)
> {
> _Tp __term = _Tp(1);
> _Tp __sum = _Tp(1);
> for (unsigned int __i = 1; __i <= __n; ++__i)
> {
> _Tp __prev = __term;
> __term *= -(__n - __i + 1) / __x;
> if (std::abs(__term) > std::abs(__prev))
> break;
> __sum += __term;
> }
>
> return std::exp(-__x) * __sum / __x;
> }
># 442 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint_large_n(unsigned int __n, _Tp __x)
> {
> const _Tp __xpn = __x + __n;
> const _Tp __xpn2 = __xpn * __xpn;
> _Tp __term = _Tp(1);
> _Tp __sum = _Tp(1);
> for (unsigned int __i = 1; __i <= __n; ++__i)
> {
> _Tp __prev = __term;
> __term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
> if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
> break;
> __sum += __term;
> }
>
> return std::exp(-__x) * __sum / __xpn;
> }
># 476 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> _Tp
> __expint(unsigned int __n, _Tp __x)
> {
>
> if (__isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__n <= 1 && __x == _Tp(0))
> return std::numeric_limits<_Tp>::infinity();
> else
> {
> _Tp __E0 = std::exp(__x) / __x;
> if (__n == 0)
> return __E0;
>
> _Tp __E1 = __expint_E1(__x);
> if (__n == 1)
> return __E1;
>
> if (__x == _Tp(0))
> return _Tp(1) / static_cast<_Tp>(__n - 1);
>
> _Tp __En = __expint_En_recursion(__n, __x);
>
> return __En;
> }
> }
># 516 "/usr/include/c++/8/tr1/exp_integral.tcc" 3
> template<typename _Tp>
> inline _Tp
> __expint(_Tp __x)
> {
> if (__isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else
> return __expint_Ei(__x);
> }
> }
>
>
>
>
>
>}
># 54 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/hypergeometric.tcc" 1 3
># 44 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 60 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> namespace __detail
> {
># 83 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> template<typename _Tp>
> _Tp
> __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
> {
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
>
> _Tp __term = _Tp(1);
> _Tp __Fac = _Tp(1);
> const unsigned int __max_iter = 100000;
> unsigned int __i;
> for (__i = 0; __i < __max_iter; ++__i)
> {
> __term *= (__a + _Tp(__i)) * __x
> / ((__c + _Tp(__i)) * _Tp(1 + __i));
> if (std::abs(__term) < __eps)
> {
> break;
> }
> __Fac += __term;
> }
> if (__i == __max_iter)
> std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.")
> );
>
> return __Fac;
> }
># 120 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> template<typename _Tp>
> _Tp
> __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
> {
> const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
> const int __nmax = 20000;
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __x = -__xin;
> const _Tp __x3 = __x * __x * __x;
> const _Tp __t0 = __a / __c;
> const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
> const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
> _Tp __F = _Tp(1);
> _Tp __prec;
>
> _Tp __Bnm3 = _Tp(1);
> _Tp __Bnm2 = _Tp(1) + __t1 * __x;
> _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
>
> _Tp __Anm3 = _Tp(1);
> _Tp __Anm2 = __Bnm2 - __t0 * __x;
> _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
> + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
>
> int __n = 3;
> while(1)
> {
> _Tp __npam1 = _Tp(__n - 1) + __a;
> _Tp __npcm1 = _Tp(__n - 1) + __c;
> _Tp __npam2 = _Tp(__n - 2) + __a;
> _Tp __npcm2 = _Tp(__n - 2) + __c;
> _Tp __tnm1 = _Tp(2 * __n - 1);
> _Tp __tnm3 = _Tp(2 * __n - 3);
> _Tp __tnm5 = _Tp(2 * __n - 5);
> _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
> _Tp __F2 = (_Tp(__n) + __a) * __npam1
> / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
> _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
> / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
> * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
> _Tp __E = -__npam1 * (_Tp(__n - 1) - __c)
> / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
>
> _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
> + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
> _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
> + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
> _Tp __r = __An / __Bn;
>
> __prec = std::abs((__F - __r) / __F);
> __F = __r;
>
> if (__prec < __eps || __n > __nmax)
> break;
>
> if (std::abs(__An) > __big || std::abs(__Bn) > __big)
> {
> __An /= __big;
> __Bn /= __big;
> __Anm1 /= __big;
> __Bnm1 /= __big;
> __Anm2 /= __big;
> __Bnm2 /= __big;
> __Anm3 /= __big;
> __Bnm3 /= __big;
> }
> else if (std::abs(__An) < _Tp(1) / __big
> || std::abs(__Bn) < _Tp(1) / __big)
> {
> __An *= __big;
> __Bn *= __big;
> __Anm1 *= __big;
> __Bnm1 *= __big;
> __Anm2 *= __big;
> __Bnm2 *= __big;
> __Anm3 *= __big;
> __Bnm3 *= __big;
> }
>
> ++__n;
> __Bnm3 = __Bnm2;
> __Bnm2 = __Bnm1;
> __Bnm1 = __Bn;
> __Anm3 = __Anm2;
> __Anm2 = __Anm1;
> __Anm1 = __An;
> }
>
> if (__n >= __nmax)
> std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.")
> );
>
> return __F;
> }
># 227 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> template<typename _Tp>
> _Tp
> __conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
> {
>
> const _Tp __c_nint = ::std::nearbyint(__c);
>
>
>
> if (__isnan(__a) || __isnan(__c) || __isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__c_nint == __c && __c_nint <= 0)
> return std::numeric_limits<_Tp>::infinity();
> else if (__a == _Tp(0))
> return _Tp(1);
> else if (__c == __a)
> return std::exp(__x);
> else if (__x < _Tp(0))
> return __conf_hyperg_luke(__a, __c, __x);
> else
> return __conf_hyperg_series(__a, __c, __x);
> }
># 271 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> template<typename _Tp>
> _Tp
> __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
> {
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
>
> _Tp __term = _Tp(1);
> _Tp __Fabc = _Tp(1);
> const unsigned int __max_iter = 100000;
> unsigned int __i;
> for (__i = 0; __i < __max_iter; ++__i)
> {
> __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
> / ((__c + _Tp(__i)) * _Tp(1 + __i));
> if (std::abs(__term) < __eps)
> {
> break;
> }
> __Fabc += __term;
> }
> if (__i == __max_iter)
> std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.")
> );
>
> return __Fabc;
> }
>
>
>
>
>
>
>
> template<typename _Tp>
> _Tp
> __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
> {
> const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
> const int __nmax = 20000;
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __x = -__xin;
> const _Tp __x3 = __x * __x * __x;
> const _Tp __t0 = __a * __b / __c;
> const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
> const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
> / (_Tp(2) * (__c + _Tp(1)));
>
> _Tp __F = _Tp(1);
>
> _Tp __Bnm3 = _Tp(1);
> _Tp __Bnm2 = _Tp(1) + __t1 * __x;
> _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
>
> _Tp __Anm3 = _Tp(1);
> _Tp __Anm2 = __Bnm2 - __t0 * __x;
> _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
> + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
>
> int __n = 3;
> while (1)
> {
> const _Tp __npam1 = _Tp(__n - 1) + __a;
> const _Tp __npbm1 = _Tp(__n - 1) + __b;
> const _Tp __npcm1 = _Tp(__n - 1) + __c;
> const _Tp __npam2 = _Tp(__n - 2) + __a;
> const _Tp __npbm2 = _Tp(__n - 2) + __b;
> const _Tp __npcm2 = _Tp(__n - 2) + __c;
> const _Tp __tnm1 = _Tp(2 * __n - 1);
> const _Tp __tnm3 = _Tp(2 * __n - 3);
> const _Tp __tnm5 = _Tp(2 * __n - 5);
> const _Tp __n2 = __n * __n;
> const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
> + _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
> / (_Tp(2) * __tnm3 * __npcm1);
> const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
> + _Tp(2) - __a * __b) * __npam1 * __npbm1
> / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
> const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
> * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
> / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
> * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
> const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
> / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
>
> _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
> + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
> _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
> + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
> const _Tp __r = __An / __Bn;
>
> const _Tp __prec = std::abs((__F - __r) / __F);
> __F = __r;
>
> if (__prec < __eps || __n > __nmax)
> break;
>
> if (std::abs(__An) > __big || std::abs(__Bn) > __big)
> {
> __An /= __big;
> __Bn /= __big;
> __Anm1 /= __big;
> __Bnm1 /= __big;
> __Anm2 /= __big;
> __Bnm2 /= __big;
> __Anm3 /= __big;
> __Bnm3 /= __big;
> }
> else if (std::abs(__An) < _Tp(1) / __big
> || std::abs(__Bn) < _Tp(1) / __big)
> {
> __An *= __big;
> __Bn *= __big;
> __Anm1 *= __big;
> __Bnm1 *= __big;
> __Anm2 *= __big;
> __Bnm2 *= __big;
> __Anm3 *= __big;
> __Bnm3 *= __big;
> }
>
> ++__n;
> __Bnm3 = __Bnm2;
> __Bnm2 = __Bnm1;
> __Bnm1 = __Bn;
> __Anm3 = __Anm2;
> __Anm2 = __Anm1;
> __Anm1 = __An;
> }
>
> if (__n >= __nmax)
> std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.")
> );
>
> return __F;
> }
># 438 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> template<typename _Tp>
> _Tp
> __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
> {
> const _Tp __d = __c - __a - __b;
> const int __intd = std::floor(__d + _Tp(0.5L));
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __toler = _Tp(1000) * __eps;
> const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
> const bool __d_integer = (std::abs(__d - __intd) < __toler);
>
> if (__d_integer)
> {
> const _Tp __ln_omx = std::log(_Tp(1) - __x);
> const _Tp __ad = std::abs(__d);
> _Tp __F1, __F2;
>
> _Tp __d1, __d2;
> if (__d >= _Tp(0))
> {
> __d1 = __d;
> __d2 = _Tp(0);
> }
> else
> {
> __d1 = _Tp(0);
> __d2 = __d;
> }
>
> const _Tp __lng_c = __log_gamma(__c);
>
>
> if (__ad < __eps)
> {
>
> __F1 = _Tp(0);
> }
> else
> {
>
> bool __ok_d1 = true;
> _Tp __lng_ad, __lng_ad1, __lng_bd1;
> try
> {
> __lng_ad = __log_gamma(__ad);
> __lng_ad1 = __log_gamma(__a + __d1);
> __lng_bd1 = __log_gamma(__b + __d1);
> }
> catch(...)
> {
> __ok_d1 = false;
> }
>
> if (__ok_d1)
> {
>
>
>
> _Tp __sum1 = _Tp(1);
> _Tp __term = _Tp(1);
> _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
> - __lng_ad1 - __lng_bd1;
>
>
>
> for (int __i = 1; __i < __ad; ++__i)
> {
> const int __j = __i - 1;
> __term *= (__a + __d2 + __j) * (__b + __d2 + __j)
> / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
> __sum1 += __term;
> }
>
> if (__ln_pre1 > __log_max)
> std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.")
> );
> else
> __F1 = std::exp(__ln_pre1) * __sum1;
> }
> else
> {
>
>
> __F1 = _Tp(0);
> }
> }
>
>
> bool __ok_d2 = true;
> _Tp __lng_ad2, __lng_bd2;
> try
> {
> __lng_ad2 = __log_gamma(__a + __d2);
> __lng_bd2 = __log_gamma(__b + __d2);
> }
> catch(...)
> {
> __ok_d2 = false;
> }
>
> if (__ok_d2)
> {
>
>
> const int __maxiter = 2000;
> const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
> const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
> const _Tp __psi_apd1 = __psi(__a + __d1);
> const _Tp __psi_bpd1 = __psi(__b + __d1);
>
> _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
> - __psi_bpd1 - __ln_omx;
> _Tp __fact = _Tp(1);
> _Tp __sum2 = __psi_term;
> _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
> - __lng_ad2 - __lng_bd2;
>
>
> int __j;
> for (__j = 1; __j < __maxiter; ++__j)
> {
>
>
> const _Tp __term1 = _Tp(1) / _Tp(__j)
> + _Tp(1) / (__ad + __j);
> const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
> + _Tp(1) / (__b + __d1 + _Tp(__j - 1));
> __psi_term += __term1 - __term2;
> __fact *= (__a + __d1 + _Tp(__j - 1))
> * (__b + __d1 + _Tp(__j - 1))
> / ((__ad + __j) * __j) * (_Tp(1) - __x);
> const _Tp __delta = __fact * __psi_term;
> __sum2 += __delta;
> if (std::abs(__delta) < __eps * std::abs(__sum2))
> break;
> }
> if (__j == __maxiter)
> std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect")
> );
>
> if (__sum2 == _Tp(0))
> __F2 = _Tp(0);
> else
> __F2 = std::exp(__ln_pre2) * __sum2;
> }
> else
> {
>
>
> __F2 = _Tp(0);
> }
>
> const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
> const _Tp __F = __F1 + __sgn_2 * __F2;
>
> return __F;
> }
> else
> {
>
>
>
>
> bool __ok1 = true;
> _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
> _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
> try
> {
> __sgn_g1ca = __log_gamma_sign(__c - __a);
> __ln_g1ca = __log_gamma(__c - __a);
> __sgn_g1cb = __log_gamma_sign(__c - __b);
> __ln_g1cb = __log_gamma(__c - __b);
> }
> catch(...)
> {
> __ok1 = false;
> }
>
> bool __ok2 = true;
> _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
> _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
> try
> {
> __sgn_g2a = __log_gamma_sign(__a);
> __ln_g2a = __log_gamma(__a);
> __sgn_g2b = __log_gamma_sign(__b);
> __ln_g2b = __log_gamma(__b);
> }
> catch(...)
> {
> __ok2 = false;
> }
>
> const _Tp __sgn_gc = __log_gamma_sign(__c);
> const _Tp __ln_gc = __log_gamma(__c);
> const _Tp __sgn_gd = __log_gamma_sign(__d);
> const _Tp __ln_gd = __log_gamma(__d);
> const _Tp __sgn_gmd = __log_gamma_sign(-__d);
> const _Tp __ln_gmd = __log_gamma(-__d);
>
> const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb;
> const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b;
>
> _Tp __pre1, __pre2;
> if (__ok1 && __ok2)
> {
> _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
> _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
> + __d * std::log(_Tp(1) - __x);
> if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
> {
> __pre1 = std::exp(__ln_pre1);
> __pre2 = std::exp(__ln_pre2);
> __pre1 *= __sgn1;
> __pre2 *= __sgn2;
> }
> else
> {
> std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
> );
> }
> }
> else if (__ok1 && !__ok2)
> {
> _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
> if (__ln_pre1 < __log_max)
> {
> __pre1 = std::exp(__ln_pre1);
> __pre1 *= __sgn1;
> __pre2 = _Tp(0);
> }
> else
> {
> std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
> );
> }
> }
> else if (!__ok1 && __ok2)
> {
> _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
> + __d * std::log(_Tp(1) - __x);
> if (__ln_pre2 < __log_max)
> {
> __pre1 = _Tp(0);
> __pre2 = std::exp(__ln_pre2);
> __pre2 *= __sgn2;
> }
> else
> {
> std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
> );
> }
> }
> else
> {
> __pre1 = _Tp(0);
> __pre2 = _Tp(0);
> std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect")
> );
> }
>
> const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
> _Tp(1) - __x);
> const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
> _Tp(1) - __x);
>
> const _Tp __F = __pre1 * __F1 + __pre2 * __F2;
>
> return __F;
> }
> }
># 728 "/usr/include/c++/8/tr1/hypergeometric.tcc" 3
> template<typename _Tp>
> _Tp
> __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
> {
>
> const _Tp __a_nint = ::std::nearbyint(__a);
> const _Tp __b_nint = ::std::nearbyint(__b);
> const _Tp __c_nint = ::std::nearbyint(__c);
>
>
>
>
>
> const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
> if (std::abs(__x) >= _Tp(1))
> std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.")
> );
> else if (__isnan(__a) || __isnan(__b)
> || __isnan(__c) || __isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__c_nint == __c && __c_nint <= _Tp(0))
> return std::numeric_limits<_Tp>::infinity();
> else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
> return std::pow(_Tp(1) - __x, __c - __a - __b);
> else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
> && __x >= _Tp(0) && __x < _Tp(0.995L))
> return __hyperg_series(__a, __b, __c, __x);
> else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
> {
>
>
> if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler)
> return __hyperg_series(__a_nint, __b, __c, __x);
> else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler)
> return __hyperg_series(__a, __b_nint, __c, __x);
> else if (__x < -_Tp(0.25L))
> return __hyperg_luke(__a, __b, __c, __x);
> else if (__x < _Tp(0.5L))
> return __hyperg_series(__a, __b, __c, __x);
> else
> if (std::abs(__c) > _Tp(10))
> return __hyperg_series(__a, __b, __c, __x);
> else
> return __hyperg_reflect(__a, __b, __c, __x);
> }
> else
> return __hyperg_luke(__a, __b, __c, __x);
> }
> }
>
>
>
>
>
>
>}
># 55 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/legendre_function.tcc" 1 3
># 49 "/usr/include/c++/8/tr1/legendre_function.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 65 "/usr/include/c++/8/tr1/legendre_function.tcc" 3
> namespace __detail
> {
># 80 "/usr/include/c++/8/tr1/legendre_function.tcc" 3
> template<typename _Tp>
> _Tp
> __poly_legendre_p(unsigned int __l, _Tp __x)
> {
>
> if ((__x < _Tp(-1)) || (__x > _Tp(+1)))
> std::__throw_domain_error(("Argument out of range" " in __poly_legendre_p.")
> );
> else 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;
> }
> }
># 137 "/usr/include/c++/8/tr1/legendre_function.tcc" 3
> template<typename _Tp>
> _Tp
> __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x)
> {
>
> if (__x < _Tp(-1) || __x > _Tp(+1))
> std::__throw_domain_error(("Argument out of range" " in __assoc_legendre_p.")
> );
> else if (__m > __l)
> std::__throw_domain_error(("Degree out of range" " in __assoc_legendre_p.")
> );
> 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 *= -__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;
> }
> }
># 216 "/usr/include/c++/8/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 (__l < __m)
> {
> std::__throw_domain_error(("Bad argument " "in __sph_legendre.")
> );
> }
> 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);
> _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
> / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
> _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
> _Tp __y_mp1m = __y_mp1m_factor * __y_mm;
>
> if (__l == __m)
> {
> return __y_mm;
> }
> else if (__l == __m + 1)
> {
> return __y_mp1m;
> }
> else
> {
> _Tp __y_lm = _Tp(0);
>
>
> for ( int __ll = __m + 2; __ll <= __l; ++__ll)
> {
> const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
> const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
> const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
> * _Tp(2 * __ll - 1));
> const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
> / _Tp(2 * __ll - 3));
> __y_lm = (__x * __y_mp1m * __fact1
> - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
> __y_mm = __y_mp1m;
> __y_mp1m = __y_lm;
> }
>
> return __y_lm;
> }
> }
> }
> }
>
>
>
>
>
>
>}
># 56 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 1 3
># 51 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 65 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
> namespace __detail
> {
># 83 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
> template <typename _Tp>
> void
> __bessel_ik(_Tp __nu, _Tp __x,
> _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
> {
> if (__x == _Tp(0))
> {
> if (__nu == _Tp(0))
> {
> __Inu = _Tp(1);
> __Ipnu = _Tp(0);
> }
> else if (__nu == _Tp(1))
> {
> __Inu = _Tp(0);
> __Ipnu = _Tp(0.5L);
> }
> else
> {
> __Inu = _Tp(0);
> __Ipnu = _Tp(0);
> }
> __Knu = std::numeric_limits<_Tp>::infinity();
> __Kpnu = -std::numeric_limits<_Tp>::infinity();
> return;
> }
>
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
> const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
> const int __max_iter = 15000;
> const _Tp __x_min = _Tp(2);
>
> const int __nl = static_cast<int>(__nu + _Tp(0.5L));
>
> const _Tp __mu = __nu - __nl;
> const _Tp __mu2 = __mu * __mu;
> const _Tp __xi = _Tp(1) / __x;
> const _Tp __xi2 = _Tp(2) * __xi;
> _Tp __h = __nu * __xi;
> if ( __h < __fp_min )
> __h = __fp_min;
> _Tp __b = __xi2 * __nu;
> _Tp __d = _Tp(0);
> _Tp __c = __h;
> int __i;
> for ( __i = 1; __i <= __max_iter; ++__i )
> {
> __b += __xi2;
> __d = _Tp(1) / (__b + __d);
> __c = __b + _Tp(1) / __c;
> const _Tp __del = __c * __d;
> __h *= __del;
> if (std::abs(__del - _Tp(1)) < __eps)
> break;
> }
> if (__i > __max_iter)
> std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.")
>
> );
> _Tp __Inul = __fp_min;
> _Tp __Ipnul = __h * __Inul;
> _Tp __Inul1 = __Inul;
> _Tp __Ipnu1 = __Ipnul;
> _Tp __fact = __nu * __xi;
> for (int __l = __nl; __l >= 1; --__l)
> {
> const _Tp __Inutemp = __fact * __Inul + __Ipnul;
> __fact -= __xi;
> __Ipnul = __fact * __Inutemp + __Inul;
> __Inul = __Inutemp;
> }
> _Tp __f = __Ipnul / __Inul;
> _Tp __Kmu, __Knu1;
> if (__x < __x_min)
> {
> const _Tp __x2 = __x / _Tp(2);
> const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
> const _Tp __fact = (std::abs(__pimu) < __eps
> ? _Tp(1) : __pimu / std::sin(__pimu));
> _Tp __d = -std::log(__x2);
> _Tp __e = __mu * __d;
> const _Tp __fact2 = (std::abs(__e) < __eps
> ? _Tp(1) : std::sinh(__e) / __e);
> _Tp __gam1, __gam2, __gampl, __gammi;
> __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
> _Tp __ff = __fact
> * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
> _Tp __sum = __ff;
> __e = std::exp(__e);
> _Tp __p = __e / (_Tp(2) * __gampl);
> _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
> _Tp __c = _Tp(1);
> __d = __x2 * __x2;
> _Tp __sum1 = __p;
> int __i;
> for (__i = 1; __i <= __max_iter; ++__i)
> {
> __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
> __c *= __d / __i;
> __p /= __i - __mu;
> __q /= __i + __mu;
> const _Tp __del = __c * __ff;
> __sum += __del;
> const _Tp __del1 = __c * (__p - __i * __ff);
> __sum1 += __del1;
> if (std::abs(__del) < __eps * std::abs(__sum))
> break;
> }
> if (__i > __max_iter)
> std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.")
> );
> __Kmu = __sum;
> __Knu1 = __sum1 * __xi2;
> }
> else
> {
> _Tp __b = _Tp(2) * (_Tp(1) + __x);
> _Tp __d = _Tp(1) / __b;
> _Tp __delh = __d;
> _Tp __h = __delh;
> _Tp __q1 = _Tp(0);
> _Tp __q2 = _Tp(1);
> _Tp __a1 = _Tp(0.25L) - __mu2;
> _Tp __q = __c = __a1;
> _Tp __a = -__a1;
> _Tp __s = _Tp(1) + __q * __delh;
> int __i;
> for (__i = 2; __i <= __max_iter; ++__i)
> {
> __a -= 2 * (__i - 1);
> __c = -__a * __c / __i;
> const _Tp __qnew = (__q1 - __b * __q2) / __a;
> __q1 = __q2;
> __q2 = __qnew;
> __q += __c * __qnew;
> __b += _Tp(2);
> __d = _Tp(1) / (__b + __a * __d);
> __delh = (__b * __d - _Tp(1)) * __delh;
> __h += __delh;
> const _Tp __dels = __q * __delh;
> __s += __dels;
> if ( std::abs(__dels / __s) < __eps )
> break;
> }
> if (__i > __max_iter)
> std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.")
> );
> __h = __a1 * __h;
> __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
> * std::exp(-__x) / __s;
> __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
> }
>
> _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
> _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
> __Inu = __Inumu * __Inul1 / __Inul;
> __Ipnu = __Inumu * __Ipnu1 / __Inul;
> for ( __i = 1; __i <= __nl; ++__i )
> {
> const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
> __Kmu = __Knu1;
> __Knu1 = __Knutemp;
> }
> __Knu = __Kmu;
> __Kpnu = __nu * __xi * __Kmu - __Knu1;
>
> return;
> }
># 267 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
> template<typename _Tp>
> _Tp
> __cyl_bessel_i(_Tp __nu, _Tp __x)
> {
> if (__nu < _Tp(0) || __x < _Tp(0))
> std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.")
> );
> else if (__isnan(__nu) || __isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
> return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
> else
> {
> _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
> __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
> return __I_nu;
> }
> }
># 303 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
> template<typename _Tp>
> _Tp
> __cyl_bessel_k(_Tp __nu, _Tp __x)
> {
> if (__nu < _Tp(0) || __x < _Tp(0))
> std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.")
> );
> else if (__isnan(__nu) || __isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else
> {
> _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
> __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
> return __K_nu;
> }
> }
># 337 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
> template <typename _Tp>
> void
> __sph_bessel_ik(unsigned int __n, _Tp __x,
> _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
> {
> const _Tp __nu = _Tp(__n) + _Tp(0.5L);
>
> _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
> __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
>
> const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
> / std::sqrt(__x);
>
> __i_n = __factor * __I_nu;
> __k_n = __factor * __K_nu;
> __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
> __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);
>
> return;
> }
># 373 "/usr/include/c++/8/tr1/modified_bessel_func.tcc" 3
> template <typename _Tp>
> void
> __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
> {
> const _Tp __absx = std::abs(__x);
> const _Tp __rootx = std::sqrt(__absx);
> const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
> const _Tp _S_NaN = std::numeric_limits<_Tp>::quiet_NaN();
> const _Tp _S_inf = std::numeric_limits<_Tp>::infinity();
>
> if (__isnan(__x))
> __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN();
> else if (__z == _S_inf)
> {
> __Aip = __Ai = _Tp(0);
> __Bip = __Bi = _S_inf;
> }
> else if (__z == -_S_inf)
> __Bip = __Aip = __Bi = __Ai = _Tp(0);
> else if (__x > _Tp(0))
> {
> _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
>
> __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
> __Ai = __rootx * __K_nu
> / (__numeric_constants<_Tp>::__sqrt3()
> * __numeric_constants<_Tp>::__pi());
> __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
> + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());
>
> __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
> __Aip = -__x * __K_nu
> / (__numeric_constants<_Tp>::__sqrt3()
> * __numeric_constants<_Tp>::__pi());
> __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
> + _Tp(2) * __I_nu
> / __numeric_constants<_Tp>::__sqrt3());
> }
> else if (__x < _Tp(0))
> {
> _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;
>
> __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
> __Ai = __rootx * (__J_nu
> - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
> __Bi = -__rootx * (__N_nu
> + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
>
> __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
> __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
> + __J_nu) / _Tp(2);
> __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
> - __N_nu) / _Tp(2);
> }
> else
> {
>
>
>
> __Ai = _Tp(0.35502805388781723926L);
> __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();
>
>
>
>
> __Aip = -_Tp(0.25881940379280679840L);
> __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
> }
>
> return;
> }
> }
>
>
>
>
>
>}
># 57 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/poly_hermite.tcc" 1 3
># 42 "/usr/include/c++/8/tr1/poly_hermite.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 56 "/usr/include/c++/8/tr1/poly_hermite.tcc" 3
> namespace __detail
> {
># 72 "/usr/include/c++/8/tr1/poly_hermite.tcc" 3
> template<typename _Tp>
> _Tp
> __poly_hermite_recursion(unsigned int __n, _Tp __x)
> {
>
> _Tp __H_0 = 1;
> if (__n == 0)
> return __H_0;
>
>
> _Tp __H_1 = 2 * __x;
> if (__n == 1)
> return __H_1;
>
>
> _Tp __H_n, __H_nm1, __H_nm2;
> unsigned int __i;
> for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
> {
> __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
> __H_nm2 = __H_nm1;
> __H_nm1 = __H_n;
> }
>
> return __H_n;
> }
># 114 "/usr/include/c++/8/tr1/poly_hermite.tcc" 3
> template<typename _Tp>
> inline _Tp
> __poly_hermite(unsigned int __n, _Tp __x)
> {
> if (__isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else
> return __poly_hermite_recursion(__n, __x);
> }
> }
>
>
>
>
>
>}
># 58 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 1 3
># 44 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 60 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> namespace __detail
> {
># 75 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> template<typename _Tpa, typename _Tp>
> _Tp
> __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
> {
> const _Tp __a = -_Tp(__n);
> const _Tp __b = _Tp(__alpha1) + _Tp(1);
> const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
> const _Tp __cos2th = __x / __eta;
> const _Tp __sin2th = _Tp(1) - __cos2th;
> const _Tp __th = std::acos(std::sqrt(__cos2th));
> const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
> * __numeric_constants<_Tp>::__pi_2()
> * __eta * __eta * __cos2th * __sin2th;
>
>
> const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b);
> const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1));
>
>
>
>
>
> _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
> * std::log(_Tp(0.25L) * __x * __eta);
> _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
> _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
> + __pre_term1 - __pre_term2;
> _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
> _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
> * (_Tp(2) * __th
> - std::sin(_Tp(2) * __th))
> + __numeric_constants<_Tp>::__pi_4());
> _Tp __ser = __ser_term1 + __ser_term2;
>
> return std::exp(__lnpre) * __ser;
> }
># 129 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> template<typename _Tpa, typename _Tp>
> _Tp
> __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
> {
> const _Tp __b = _Tp(__alpha1) + _Tp(1);
> const _Tp __mx = -__x;
> const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
> : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
>
> _Tp __tc = _Tp(1);
> const _Tp __ax = std::abs(__x);
> for (unsigned int __k = 1; __k <= __n; ++__k)
> __tc *= (__ax / __k);
>
> _Tp __term = __tc * __tc_sgn;
> _Tp __sum = __term;
> for (int __k = int(__n) - 1; __k >= 0; --__k)
> {
> __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
> * _Tp(__k + 1) / __mx;
> __sum += __term;
> }
>
> return __sum;
> }
># 185 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> template<typename _Tpa, typename _Tp>
> _Tp
> __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
> {
>
> _Tp __l_0 = _Tp(1);
> if (__n == 0)
> return __l_0;
>
>
> _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
> if (__n == 1)
> return __l_1;
>
>
> _Tp __l_n2 = __l_0;
> _Tp __l_n1 = __l_1;
> _Tp __l_n = _Tp(0);
> for (unsigned int __nn = 2; __nn <= __n; ++__nn)
> {
> __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
> * __l_n1 / _Tp(__nn)
> - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
> __l_n2 = __l_n1;
> __l_n1 = __l_n;
> }
>
> return __l_n;
> }
># 244 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> template<typename _Tpa, typename _Tp>
> _Tp
> __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
> {
> if (__x < _Tp(0))
> std::__throw_domain_error(("Negative argument " "in __poly_laguerre.")
> );
>
> else if (__isnan(__x))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__n == 0)
> return _Tp(1);
> else if (__n == 1)
> return _Tp(1) + _Tp(__alpha1) - __x;
> else if (__x == _Tp(0))
> {
> _Tp __prod = _Tp(__alpha1) + _Tp(1);
> for (unsigned int __k = 2; __k <= __n; ++__k)
> __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
> return __prod;
> }
> else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
> && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
> return __poly_laguerre_large_n(__n, __alpha1, __x);
> else if (_Tp(__alpha1) >= _Tp(0)
> || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
> return __poly_laguerre_recursion(__n, __alpha1, __x);
> else
> return __poly_laguerre_hyperg(__n, __alpha1, __x);
> }
># 296 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> template<typename _Tp>
> inline _Tp
> __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
> { return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
># 316 "/usr/include/c++/8/tr1/poly_laguerre.tcc" 3
> template<typename _Tp>
> inline _Tp
> __laguerre(unsigned int __n, _Tp __x)
> { return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
> }
>
>
>
>
>
>
>}
># 59 "/usr/include/c++/8/bits/specfun.h" 2 3
># 1 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 1 3
># 47 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 63 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> namespace __detail
> {
># 78 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> _Tp
> __riemann_zeta_sum(_Tp __s)
> {
>
> if (__s < _Tp(1))
> std::__throw_domain_error(("Bad argument in zeta sum."));
>
> const unsigned int max_iter = 10000;
> _Tp __zeta = _Tp(0);
> for (unsigned int __k = 1; __k < max_iter; ++__k)
> {
> _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
> if (__term < std::numeric_limits<_Tp>::epsilon())
> {
> break;
> }
> __zeta += __term;
> }
>
> return __zeta;
> }
># 115 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> _Tp
> __riemann_zeta_alt(_Tp __s)
> {
> _Tp __sgn = _Tp(1);
> _Tp __zeta = _Tp(0);
> for (unsigned int __i = 1; __i < 10000000; ++__i)
> {
> _Tp __term = __sgn / std::pow(__i, __s);
> if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
> break;
> __zeta += __term;
> __sgn *= _Tp(-1);
> }
> __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
>
> return __zeta;
> }
># 157 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> _Tp
> __riemann_zeta_glob(_Tp __s)
> {
> _Tp __zeta = _Tp(0);
>
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
>
> const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
> * std::log(_Tp(10)) - _Tp(1);
>
>
>
> if (__s < _Tp(0))
> {
>
> if (::std::fmod(__s,_Tp(2)) == _Tp(0))
> return _Tp(0);
> else
>
> {
> _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
> __zeta *= std::pow(_Tp(2)
> * __numeric_constants<_Tp>::__pi(), __s)
> * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
>
> * std::exp(::std::lgamma(_Tp(1) - __s))
>
>
>
> / __numeric_constants<_Tp>::__pi();
> return __zeta;
> }
> }
>
> _Tp __num = _Tp(0.5L);
> const unsigned int __maxit = 10000;
> for (unsigned int __i = 0; __i < __maxit; ++__i)
> {
> bool __punt = false;
> _Tp __sgn = _Tp(1);
> _Tp __term = _Tp(0);
> for (unsigned int __j = 0; __j <= __i; ++__j)
> {
>
> _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
> - ::std::lgamma(_Tp(1 + __j))
> - ::std::lgamma(_Tp(1 + __i - __j));
>
>
>
>
>
> if (__bincoeff > __max_bincoeff)
> {
>
> __punt = true;
> break;
> }
> __bincoeff = std::exp(__bincoeff);
> __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
> __sgn *= _Tp(-1);
> }
> if (__punt)
> break;
> __term *= __num;
> __zeta += __term;
> if (std::abs(__term/__zeta) < __eps)
> break;
> __num *= _Tp(0.5L);
> }
>
> __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
>
> return __zeta;
> }
># 252 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> _Tp
> __riemann_zeta_product(_Tp __s)
> {
> static const _Tp __prime[] = {
> _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
> _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
> _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
> _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
> };
> static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);
>
> _Tp __zeta = _Tp(1);
> for (unsigned int __i = 0; __i < __num_primes; ++__i)
> {
> const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
> __zeta *= __fact;
> if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
> break;
> }
>
> __zeta = _Tp(1) / __zeta;
>
> return __zeta;
> }
># 293 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> _Tp
> __riemann_zeta(_Tp __s)
> {
> if (__isnan(__s))
> return std::numeric_limits<_Tp>::quiet_NaN();
> else if (__s == _Tp(1))
> return std::numeric_limits<_Tp>::infinity();
> else if (__s < -_Tp(19))
> {
> _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
> __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
> * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
>
> * std::exp(::std::lgamma(_Tp(1) - __s))
>
>
>
> / __numeric_constants<_Tp>::__pi();
> return __zeta;
> }
> else if (__s < _Tp(20))
> {
>
> bool __glob = true;
> if (__glob)
> return __riemann_zeta_glob(__s);
> else
> {
> if (__s > _Tp(1))
> return __riemann_zeta_sum(__s);
> else
> {
> _Tp __zeta = std::pow(_Tp(2)
> * __numeric_constants<_Tp>::__pi(), __s)
> * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
>
> * ::std::tgamma(_Tp(1) - __s)
>
>
>
> * __riemann_zeta_sum(_Tp(1) - __s);
> return __zeta;
> }
> }
> }
> else
> return __riemann_zeta_product(__s);
> }
># 365 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> _Tp
> __hurwitz_zeta_glob(_Tp __a, _Tp __s)
> {
> _Tp __zeta = _Tp(0);
>
> const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
>
> const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
> * std::log(_Tp(10)) - _Tp(1);
>
> const unsigned int __maxit = 10000;
> for (unsigned int __i = 0; __i < __maxit; ++__i)
> {
> bool __punt = false;
> _Tp __sgn = _Tp(1);
> _Tp __term = _Tp(0);
> for (unsigned int __j = 0; __j <= __i; ++__j)
> {
>
> _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
> - ::std::lgamma(_Tp(1 + __j))
> - ::std::lgamma(_Tp(1 + __i - __j));
>
>
>
>
>
> if (__bincoeff > __max_bincoeff)
> {
>
> __punt = true;
> break;
> }
> __bincoeff = std::exp(__bincoeff);
> __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
> __sgn *= _Tp(-1);
> }
> if (__punt)
> break;
> __term /= _Tp(__i + 1);
> if (std::abs(__term / __zeta) < __eps)
> break;
> __zeta += __term;
> }
>
> __zeta /= __s - _Tp(1);
>
> return __zeta;
> }
># 430 "/usr/include/c++/8/tr1/riemann_zeta.tcc" 3
> template<typename _Tp>
> inline _Tp
> __hurwitz_zeta(_Tp __a, _Tp __s)
> { return __hurwitz_zeta_glob(__a, __s); }
> }
>
>
>
>
>
>
>}
># 60 "/usr/include/c++/8/bits/specfun.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 205 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
> { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
>
>
>
>
>
>
>
> inline long double
> assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
> { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
># 250 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__assoc_laguerre<__type>(__n, __m, __x);
> }
># 266 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> assoc_legendref(unsigned int __l, unsigned int __m, float __x)
> { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
>
>
>
>
>
>
> inline long double
> assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
> { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
># 296 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
> }
># 311 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> betaf(float __a, float __b)
> { return __detail::__beta<float>(__a, __b); }
>
>
>
>
>
>
>
> inline long double
> betal(long double __a, long double __b)
> { return __detail::__beta<long double>(__a, __b); }
># 341 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tpa, typename _Tpb>
> inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
> beta(_Tpa __a, _Tpb __b)
> {
> typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
> return __detail::__beta<__type>(__a, __b);
> }
># 357 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> comp_ellint_1f(float __k)
> { return __detail::__comp_ellint_1<float>(__k); }
>
>
>
>
>
>
>
> inline long double
> comp_ellint_1l(long double __k)
> { return __detail::__comp_ellint_1<long double>(__k); }
># 389 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> comp_ellint_1(_Tp __k)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__comp_ellint_1<__type>(__k);
> }
># 405 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> comp_ellint_2f(float __k)
> { return __detail::__comp_ellint_2<float>(__k); }
>
>
>
>
>
>
>
> inline long double
> comp_ellint_2l(long double __k)
> { return __detail::__comp_ellint_2<long double>(__k); }
># 436 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> comp_ellint_2(_Tp __k)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__comp_ellint_2<__type>(__k);
> }
># 452 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> comp_ellint_3f(float __k, float __nu)
> { return __detail::__comp_ellint_3<float>(__k, __nu); }
>
>
>
>
>
>
>
> inline long double
> comp_ellint_3l(long double __k, long double __nu)
> { return __detail::__comp_ellint_3<long double>(__k, __nu); }
># 487 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp, typename _Tpn>
> inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
> comp_ellint_3(_Tp __k, _Tpn __nu)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
> return __detail::__comp_ellint_3<__type>(__k, __nu);
> }
># 503 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> cyl_bessel_if(float __nu, float __x)
> { return __detail::__cyl_bessel_i<float>(__nu, __x); }
>
>
>
>
>
>
>
> inline long double
> cyl_bessel_il(long double __nu, long double __x)
> { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
># 533 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tpnu, typename _Tp>
> inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
> cyl_bessel_i(_Tpnu __nu, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
> return __detail::__cyl_bessel_i<__type>(__nu, __x);
> }
># 549 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> cyl_bessel_jf(float __nu, float __x)
> { return __detail::__cyl_bessel_j<float>(__nu, __x); }
>
>
>
>
>
>
>
> inline long double
> cyl_bessel_jl(long double __nu, long double __x)
> { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
># 579 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tpnu, typename _Tp>
> inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
> cyl_bessel_j(_Tpnu __nu, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
> return __detail::__cyl_bessel_j<__type>(__nu, __x);
> }
># 595 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> cyl_bessel_kf(float __nu, float __x)
> { return __detail::__cyl_bessel_k<float>(__nu, __x); }
>
>
>
>
>
>
>
> inline long double
> cyl_bessel_kl(long double __nu, long double __x)
> { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
># 631 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tpnu, typename _Tp>
> inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
> cyl_bessel_k(_Tpnu __nu, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
> return __detail::__cyl_bessel_k<__type>(__nu, __x);
> }
># 647 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> cyl_neumannf(float __nu, float __x)
> { return __detail::__cyl_neumann_n<float>(__nu, __x); }
>
>
>
>
>
>
>
> inline long double
> cyl_neumannl(long double __nu, long double __x)
> { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
># 679 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tpnu, typename _Tp>
> inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
> cyl_neumann(_Tpnu __nu, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
> return __detail::__cyl_neumann_n<__type>(__nu, __x);
> }
># 695 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> ellint_1f(float __k, float __phi)
> { return __detail::__ellint_1<float>(__k, __phi); }
>
>
>
>
>
>
>
> inline long double
> ellint_1l(long double __k, long double __phi)
> { return __detail::__ellint_1<long double>(__k, __phi); }
># 727 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp, typename _Tpp>
> inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
> ellint_1(_Tp __k, _Tpp __phi)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
> return __detail::__ellint_1<__type>(__k, __phi);
> }
># 743 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> ellint_2f(float __k, float __phi)
> { return __detail::__ellint_2<float>(__k, __phi); }
>
>
>
>
>
>
>
> inline long double
> ellint_2l(long double __k, long double __phi)
> { return __detail::__ellint_2<long double>(__k, __phi); }
># 775 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp, typename _Tpp>
> inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
> ellint_2(_Tp __k, _Tpp __phi)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
> return __detail::__ellint_2<__type>(__k, __phi);
> }
># 791 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> ellint_3f(float __k, float __nu, float __phi)
> { return __detail::__ellint_3<float>(__k, __nu, __phi); }
>
>
>
>
>
>
>
> inline long double
> ellint_3l(long double __k, long double __nu, long double __phi)
> { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
># 828 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp, typename _Tpn, typename _Tpp>
> inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
> ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
> {
> typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
> return __detail::__ellint_3<__type>(__k, __nu, __phi);
> }
># 843 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> expintf(float __x)
> { return __detail::__expint<float>(__x); }
>
>
>
>
>
>
>
> inline long double
> expintl(long double __x)
> { return __detail::__expint<long double>(__x); }
># 868 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> expint(_Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__expint<__type>(__x);
> }
># 884 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> hermitef(unsigned int __n, float __x)
> { return __detail::__poly_hermite<float>(__n, __x); }
>
>
>
>
>
>
>
> inline long double
> hermitel(unsigned int __n, long double __x)
> { return __detail::__poly_hermite<long double>(__n, __x); }
># 916 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> hermite(unsigned int __n, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__poly_hermite<__type>(__n, __x);
> }
># 932 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> laguerref(unsigned int __n, float __x)
> { return __detail::__laguerre<float>(__n, __x); }
>
>
>
>
>
>
>
> inline long double
> laguerrel(unsigned int __n, long double __x)
> { return __detail::__laguerre<long double>(__n, __x); }
># 960 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> laguerre(unsigned int __n, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__laguerre<__type>(__n, __x);
> }
># 976 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> legendref(unsigned int __l, float __x)
> { return __detail::__poly_legendre_p<float>(__l, __x); }
>
>
>
>
>
>
>
> inline long double
> legendrel(unsigned int __l, long double __x)
> { return __detail::__poly_legendre_p<long double>(__l, __x); }
># 1005 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> legendre(unsigned int __l, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__poly_legendre_p<__type>(__l, __x);
> }
># 1021 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> riemann_zetaf(float __s)
> { return __detail::__riemann_zeta<float>(__s); }
>
>
>
>
>
>
>
> inline long double
> riemann_zetal(long double __s)
> { return __detail::__riemann_zeta<long double>(__s); }
># 1056 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> riemann_zeta(_Tp __s)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__riemann_zeta<__type>(__s);
> }
># 1072 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> sph_besself(unsigned int __n, float __x)
> { return __detail::__sph_bessel<float>(__n, __x); }
>
>
>
>
>
>
>
> inline long double
> sph_bessell(unsigned int __n, long double __x)
> { return __detail::__sph_bessel<long double>(__n, __x); }
># 1100 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> sph_bessel(unsigned int __n, _Tp __x)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__sph_bessel<__type>(__n, __x);
> }
># 1116 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> sph_legendref(unsigned int __l, unsigned int __m, float __theta)
> { return __detail::__sph_legendre<float>(__l, __m, __theta); }
># 1127 "/usr/include/c++/8/bits/specfun.h" 3
> inline long double
> sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
> { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
># 1147 "/usr/include/c++/8/bits/specfun.h" 3
> template<typename _Tp>
> inline typename __gnu_cxx::__promote<_Tp>::__type
> sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
> {
> typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
> return __detail::__sph_legendre<__type>(__l, __m, __theta);
> }
># 1163 "/usr/include/c++/8/bits/specfun.h" 3
> inline float
> sph_neumannf(unsigned int __n, float __x)
> { return __detail::__sph_neumann<float>(__n, __x); }
>
>
>
>
>
>
>
> inline long double
> sph_neumannl(unsigned int __n, long double __x)
> { return __detail::__sph_neumann<long double>(__n, __x); }
># 1191 "/usr/include/c++/8/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);
> }
>
>
>
>
>}
># 1383 "/usr/include/c++/8/bits/specfun.h" 3
>#pragma GCC visibility pop
># 1893 "/usr/include/c++/8/cmath" 2 3
>
>
>}
># 34 "/usr/local/include/fmt/format.h" 2 3
># 1 "/usr/include/c++/8/cstring" 1 3
># 39 "/usr/include/c++/8/cstring" 3
> 
># 40 "/usr/include/c++/8/cstring" 3
>
>
># 1 "/usr/include/string.h" 1 3 4
># 26 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/libc-header-start.h" 1 3 4
># 27 "/usr/include/string.h" 2 3 4
>
>extern "C" {
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 34 "/usr/include/string.h" 2 3 4
># 42 "/usr/include/string.h" 3 4
>extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
> size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, const void *__src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
> int __c, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (const void *__s1, const void *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern "C++"
>{
>extern void *memchr (void *__s, int __c, size_t __n)
> throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const void *memchr (const void *__s, int __c, size_t __n)
> throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
>memchr (void *__s, int __c, size_t __n) throw ()
>{
> return __builtin_memchr (__s, __c, __n);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
>memchr (const void *__s, int __c, size_t __n) throw ()
>{
> return __builtin_memchr (__s, __c, __n);
>}
>
>}
># 98 "/usr/include/string.h" 3 4
>extern "C++" void *rawmemchr (void *__s, int __c)
> throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const void *rawmemchr (const void *__s, int __c)
> throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern "C++" void *memrchr (void *__s, int __c, size_t __n)
> throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
> throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 121 "/usr/include/string.h" 3 4
>extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, const char *__restrict __src,
> size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (const char *__s1, const char *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
> locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>
>
>
>
>extern char *strdup (const char *__s)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern char *strndup (const char *__string, size_t __n)
> throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 203 "/usr/include/string.h" 3 4
>extern "C++"
>{
>extern char *strchr (char *__s, int __c)
> throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *strchr (const char *__s, int __c)
> throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strchr (char *__s, int __c) throw ()
>{
> return __builtin_strchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strchr (const char *__s, int __c) throw ()
>{
> return __builtin_strchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>extern "C++"
>{
>extern char *strrchr (char *__s, int __c)
> throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *strrchr (const char *__s, int __c)
> throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strrchr (char *__s, int __c) throw ()
>{
> return __builtin_strrchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strrchr (const char *__s, int __c) throw ()
>{
> return __builtin_strrchr (__s, __c);
>}
>
>}
># 260 "/usr/include/string.h" 3 4
>extern "C++" char *strchrnul (char *__s, int __c)
> throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern "C++" const char *strchrnul (const char *__s, int __c)
> throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
># 272 "/usr/include/string.h" 3 4
>extern size_t strcspn (const char *__s, const char *__reject)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (const char *__s, const char *__accept)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern "C++"
>{
>extern char *strpbrk (char *__s, const char *__accept)
> throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern const char *strpbrk (const char *__s, const char *__accept)
> throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strpbrk (char *__s, const char *__accept) throw ()
>{
> return __builtin_strpbrk (__s, __accept);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strpbrk (const char *__s, const char *__accept) throw ()
>{
> return __builtin_strpbrk (__s, __accept);
>}
>
>}
>
>
>
>
>
>
>extern "C++"
>{
>extern char *strstr (char *__haystack, const char *__needle)
> throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern const char *strstr (const char *__haystack, const char *__needle)
> throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>strstr (char *__haystack, const char *__needle) throw ()
>{
> return __builtin_strstr (__haystack, __needle);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>strstr (const char *__haystack, const char *__needle) throw ()
>{
> return __builtin_strstr (__haystack, __needle);
>}
>
>}
>
>
>
>
>
>
>
>extern char *strtok (char *__restrict __s, const char *__restrict __delim)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern char *__strtok_r (char *__restrict __s,
> const char *__restrict __delim,
> char **__restrict __save_ptr)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
> char **__restrict __save_ptr)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>extern "C++" char *strcasestr (char *__haystack, const char *__needle)
> throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>extern "C++" const char *strcasestr (const char *__haystack,
> const char *__needle)
> throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 368 "/usr/include/string.h" 3 4
>extern void *memmem (const void *__haystack, size_t __haystacklen,
> const void *__needle, size_t __needlelen)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
>
>
>
>extern void *__mempcpy (void *__restrict __dest,
> const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern void *mempcpy (void *__restrict __dest,
> const void *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern size_t strlen (const char *__s)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern size_t strnlen (const char *__string, size_t __maxlen)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern char *strerror (int __errnum) throw ();
># 420 "/usr/include/string.h" 3 4
>extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>
>
>extern char *strerror_l (int __errnum, locale_t __l) throw ();
>
>
>
># 1 "/usr/include/strings.h" 1 3 4
># 23 "/usr/include/strings.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 24 "/usr/include/strings.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
>
>
>
>extern int bcmp (const void *__s1, const void *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bcopy (const void *__src, void *__dest, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern "C++"
>{
>extern char *index (char *__s, int __c)
> throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *index (const char *__s, int __c)
> throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>index (char *__s, int __c) throw ()
>{
> return __builtin_index (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>index (const char *__s, int __c) throw ()
>{
> return __builtin_index (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>extern "C++"
>{
>extern char *rindex (char *__s, int __c)
> throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>extern const char *rindex (const char *__s, int __c)
> throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
>rindex (char *__s, int __c) throw ()
>{
> return __builtin_rindex (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
>rindex (const char *__s, int __c) throw ()
>{
> return __builtin_rindex (__s, __c);
>}
>
>}
># 104 "/usr/include/strings.h" 3 4
>extern int ffs (int __i) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int ffsl (long int __l) throw () __attribute__ ((__const__));
>__extension__ extern int ffsll (long long int __ll)
> throw () __attribute__ ((__const__));
>
>
>
>extern int strcasecmp (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>extern int strncasecmp_l (const char *__s1, const char *__s2,
> size_t __n, locale_t __loc)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
>
>
>}
># 432 "/usr/include/string.h" 2 3 4
>
>
>
>extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern char *strsep (char **__restrict __stringp,
> const char *__restrict __delim)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern char *strsignal (int __sig) throw ();
>
>
>extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *__stpncpy (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>extern char *stpncpy (char *__restrict __dest,
> const char *__restrict __src, size_t __n)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int strverscmp (const char *__s1, const char *__s2)
> throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern "C++" char *basename (char *__filename)
> throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
>extern "C++" const char *basename (const char *__filename)
> throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
># 498 "/usr/include/string.h" 3 4
>}
># 43 "/usr/include/c++/8/cstring" 2 3
># 71 "/usr/include/c++/8/cstring" 3
>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;
># 120 "/usr/include/c++/8/cstring" 3
>
>}
># 35 "/usr/local/include/fmt/format.h" 2 3
>
># 1 "/usr/include/c++/8/memory" 1 3
># 46 "/usr/include/c++/8/memory" 3
> 
># 47 "/usr/include/c++/8/memory" 3
># 65 "/usr/include/c++/8/memory" 3
># 1 "/usr/include/c++/8/bits/stl_uninitialized.h" 1 3
># 67 "/usr/include/c++/8/bits/stl_uninitialized.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<bool _TrivialValueTypes>
> struct __uninitialized_copy
> {
> template<typename _InputIterator, typename _ForwardIterator>
> static _ForwardIterator
> __uninit_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __first != __last; ++__first, (void)++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_copy<true>
> {
> template<typename _InputIterator, typename _ForwardIterator>
> static _ForwardIterator
> __uninit_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> { return std::copy(__first, __last, __result); }
> };
># 113 "/usr/include/c++/8/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _ValueType1;
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType2;
>
>
>
>
> typedef typename iterator_traits<_InputIterator>::reference _RefType1;
> typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
> const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
>
>
> return std::__uninitialized_copy<__is_trivial(_ValueType1)
> && __is_trivial(_ValueType2)
> && __assignable>::
> __uninit_copy(__first, __last, __result);
> }
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_fill
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_fill<true>
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> { std::fill(__first, __last, __x); }
> };
># 179 "/usr/include/c++/8/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
>
>
>
> const bool __assignable = is_copy_assignable<_ValueType>::value;
>
>
> std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
> __uninit_fill(__first, __last, __x);
> }
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_fill_n
> {
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> static _ForwardIterator
> __uninit_fill_n(_ForwardIterator __first, _Size __n,
> const _Tp& __x)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, (void) ++__cur)
> std::_Construct(std::__addressof(*__cur), __x);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_fill_n<true>
> {
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> static _ForwardIterator
> __uninit_fill_n(_ForwardIterator __first, _Size __n,
> const _Tp& __x)
> { return std::fill_n(__first, __n, __x); }
> };
># 242 "/usr/include/c++/8/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline _ForwardIterator
> uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
>
>
>
> const bool __assignable = is_copy_assignable<_ValueType>::value;
>
> return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
> __uninit_fill_n(__first, __n, __x);
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __result;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __first != __last; ++__first, (void)++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, allocator<_Tp>&)
> { return std::uninitialized_copy(__first, __last, __result); }
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _Allocator& __alloc)
> {
> return std::__uninitialized_copy_a(std::make_move_iterator(__first),
> std::make_move_iterator(__last),
> __result, __alloc);
> }
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_if_noexcept_a(_InputIterator __first,
> _InputIterator __last,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> return std::__uninitialized_copy_a
> (std::__make_move_if_noexcept_iterator(__first),
> std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Allocator>
> void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __cur != __last; ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Tp2>
> inline void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, allocator<_Tp2>&)
> { std::uninitialized_fill(__first, __last, __x); }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Allocator>
> _ForwardIterator
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __n > 0; --__n, (void) ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), __x);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Tp2>
> inline _ForwardIterator
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x, allocator<_Tp2>&)
> { return std::uninitialized_fill_n(__first, __n, __x); }
># 378 "/usr/include/c++/8/bits/stl_uninitialized.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_copy_move(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_copy(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
> const _Tp& __x, _InputIterator __first,
> _InputIterator __last, _Allocator& __alloc)
> {
> std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
> try
> {
> return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
> typename _Allocator>
> inline void
> __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2,
> _ForwardIterator __last2, const _Tp& __x,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
> __first2,
> __alloc);
> try
> {
> std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__first2, __mid2, __alloc);
> throw;
> }
> }
>
>
>
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_1
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_1<true>
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::fill(__first, __last, _ValueType());
> }
> };
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_n_1
> {
> template<typename _ForwardIterator, typename _Size>
> static _ForwardIterator
> __uninit_default_n(_ForwardIterator __first, _Size __n)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, (void) ++__cur)
> std::_Construct(std::__addressof(*__cur));
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_n_1<true>
> {
> template<typename _ForwardIterator, typename _Size>
> static _ForwardIterator
> __uninit_default_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> return std::fill_n(__first, __n, _ValueType());
> }
> };
>
>
>
>
> template<typename _ForwardIterator>
> inline void
> __uninitialized_default(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> const bool __assignable = is_copy_assignable<_ValueType>::value;
>
> std::__uninitialized_default_1<__is_trivial(_ValueType)
> && __assignable>::
> __uninit_default(__first, __last);
> }
>
>
>
> template<typename _ForwardIterator, typename _Size>
> inline _ForwardIterator
> __uninitialized_default_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> const bool __assignable = is_copy_assignable<_ValueType>::value;
>
> return __uninitialized_default_n_1<__is_trivial(_ValueType)
> && __assignable>::
> __uninit_default_n(__first, __n);
> }
>
>
>
>
>
> template<typename _ForwardIterator, typename _Allocator>
> void
> __uninitialized_default_a(_ForwardIterator __first,
> _ForwardIterator __last,
> _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __cur != __last; ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_default_a(_ForwardIterator __first,
> _ForwardIterator __last,
> allocator<_Tp>&)
> { std::__uninitialized_default(__first, __last); }
>
>
>
>
>
> template<typename _ForwardIterator, typename _Size, typename _Allocator>
> _ForwardIterator
> __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
> _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __n > 0; --__n, (void) ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur));
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline _ForwardIterator
> __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
> allocator<_Tp>&)
> { return std::__uninitialized_default_n(__first, __n); }
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_novalue_1
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default_novalue(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct_novalue(std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_novalue_1<true>
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default_novalue(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> }
> };
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_novalue_n_1
> {
> template<typename _ForwardIterator, typename _Size>
> static _ForwardIterator
> __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, (void) ++__cur)
> std::_Construct_novalue(std::__addressof(*__cur));
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_novalue_n_1<true>
> {
> template<typename _ForwardIterator, typename _Size>
> static _ForwardIterator
> __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
> { return std::next(__first, __n); }
> };
>
>
>
>
> template<typename _ForwardIterator>
> inline void
> __uninitialized_default_novalue(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_default_novalue_1<
> is_trivially_default_constructible<_ValueType>::value>::
> __uninit_default_novalue(__first, __last);
> }
>
>
>
> template<typename _ForwardIterator, typename _Size>
> inline _ForwardIterator
> __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> return __uninitialized_default_novalue_n_1<
> is_trivially_default_constructible<_ValueType>::value>::
> __uninit_default_novalue_n(__first, __n);
> }
>
> template<typename _InputIterator, typename _Size,
> typename _ForwardIterator>
> _ForwardIterator
> __uninitialized_copy_n(_InputIterator __first, _Size __n,
> _ForwardIterator __result, input_iterator_tag)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __n > 0; --__n, (void) ++__first, ++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
> _ForwardIterator __result,
> random_access_iterator_tag)
> { return std::uninitialized_copy(__first, __first + __n, __result); }
>
> template<typename _InputIterator, typename _Size,
> typename _ForwardIterator>
> pair<_InputIterator, _ForwardIterator>
> __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
> _ForwardIterator __result, input_iterator_tag)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __n > 0; --__n, (void) ++__first, ++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return {__first, __cur};
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _ForwardIterator>
> inline pair<_RandomAccessIterator, _ForwardIterator>
> __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
> _ForwardIterator __result,
> random_access_iterator_tag)
> {
> auto __second_res = uninitialized_copy(__first, __first + __n, __result);
> auto __first_res = std::next(__first, __n);
> return {__first_res, __second_res};
> }
># 810 "/usr/include/c++/8/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));
> }
>
>
>
>
> template <typename _ForwardIterator>
> inline void
> uninitialized_default_construct(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> __uninitialized_default_novalue(__first, __last);
> }
>
> template <typename _ForwardIterator, typename _Size>
> inline _ForwardIterator
> uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
> {
> return __uninitialized_default_novalue_n(__first, __count);
> }
>
> template <typename _ForwardIterator>
> inline void
> uninitialized_value_construct(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> return __uninitialized_default(__first, __last);
> }
>
> template <typename _ForwardIterator, typename _Size>
> inline _ForwardIterator
> uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
> {
> return __uninitialized_default_n(__first, __count);
> }
>
> 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);
> }
>
> 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};
> }
>
>
>
>}
># 66 "/usr/include/c++/8/memory" 2 3
>
># 1 "/usr/include/c++/8/bits/stl_raw_storage_iter.h" 1 3
># 59 "/usr/include/c++/8/bits/stl_raw_storage_iter.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> template <class _OutputIterator, class _Tp>
> class raw_storage_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _OutputIterator _M_iter;
>
> public:
> explicit
> raw_storage_iterator(_OutputIterator __x)
> : _M_iter(__x) {}
>
> raw_storage_iterator&
> operator*() { return *this; }
>
> raw_storage_iterator&
> operator=(const _Tp& __element)
> {
> std::_Construct(std::__addressof(*_M_iter), __element);
> return *this;
> }
>
>
>
>
> raw_storage_iterator&
> operator=(_Tp&& __element)
> {
> std::_Construct(std::__addressof(*_M_iter), std::move(__element));
> return *this;
> }
>
>
> raw_storage_iterator&
> operator++()
> {
> ++_M_iter;
> return *this;
> }
>
> raw_storage_iterator
> operator++(int)
> {
> raw_storage_iterator __tmp = *this;
> ++_M_iter;
> return __tmp;
> }
>
>
>
> _OutputIterator base() const { return _M_iter; }
> };
>
>
>}
># 68 "/usr/include/c++/8/memory" 2 3
>
>
>
>
>
>
># 1 "/usr/include/c++/8/ext/concurrence.h" 1 3
># 32 "/usr/include/c++/8/ext/concurrence.h" 3
> 
># 33 "/usr/include/c++/8/ext/concurrence.h" 3
>
>
>
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
>
>
>
> static const _Lock_policy __default_lock_policy =
>
>
>
> _S_atomic;
># 67 "/usr/include/c++/8/ext/concurrence.h" 3
> 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, 0, 0, 0, { 0, 0 } } };
>
>
>
>
> __mutex(const __mutex&);
> __mutex& operator=(const __mutex&);
>
> public:
> __mutex()
> {
>
>
>
>
> }
># 147 "/usr/include/c++/8/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()
> {
>
>
>
>
> }
># 202 "/usr/include/c++/8/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()
> {
>
>
>
>
> }
># 280 "/usr/include/c++/8/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();
> }
>
> }
> };
>
>
>
>}
># 75 "/usr/include/c++/8/memory" 2 3
>
>
># 1 "/usr/include/c++/8/bits/uses_allocator.h" 1 3
># 35 "/usr/include/c++/8/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_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
>
>
> struct allocator_arg_t { explicit allocator_arg_t() = default; };
>
> inline constexpr allocator_arg_t allocator_arg =
> allocator_arg_t();
>
> template<typename _Tp, typename _Alloc, typename = __void_t<>>
> struct __uses_allocator_helper
> : false_type { };
>
> template<typename _Tp, typename _Alloc>
> struct __uses_allocator_helper<_Tp, _Alloc,
> __void_t<typename _Tp::allocator_type>>
> : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
> { };
>
>
> template<typename _Tp, typename _Alloc>
> struct uses_allocator
> : __uses_allocator_helper<_Tp, _Alloc>::type
> { };
>
> struct __uses_alloc_base { };
>
> struct __uses_alloc0 : __uses_alloc_base
> {
> struct _Sink { void operator=(const void*) { } } _M_a;
> };
>
> template<typename _Alloc>
> struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
>
> template<typename _Alloc>
> struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
>
> template<bool, typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc;
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc<true, _Tp, _Alloc, _Args...>
> : conditional<
> is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
> __uses_alloc1<_Alloc>,
> __uses_alloc2<_Alloc>>::type
> {
> static_assert(__or_<
> is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>,
> is_constructible<_Tp, _Args..., _Alloc>>::value, "construction with"
> " an allocator must be possible if uses_allocator is true");
> };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc<false, _Tp, _Alloc, _Args...>
> : __uses_alloc0 { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> using __uses_alloc_t =
> __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> inline __uses_alloc_t<_Tp, _Alloc, _Args...>
> __use_alloc(const _Alloc& __a)
> {
> __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
> __ret._M_a = std::__addressof(__a);
> return __ret;
> }
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> void
> __use_alloc(const _Alloc&&) = delete;
>
>
> template <typename _Tp, typename _Alloc>
> inline constexpr bool uses_allocator_v =
> uses_allocator<_Tp, _Alloc>::value;
>
>
> template<template<typename...> class _Predicate,
> typename _Tp, typename _Alloc, typename... _Args>
> struct __is_uses_allocator_predicate
> : conditional<uses_allocator<_Tp, _Alloc>::value,
> __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
> _Predicate<_Tp, _Args..., _Alloc>>,
> _Predicate<_Tp, _Args...>>::type { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __is_uses_allocator_constructible
> : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
> { };
>
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> inline constexpr bool __is_uses_allocator_constructible_v =
> __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
>
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __is_nothrow_uses_allocator_constructible
> : __is_uses_allocator_predicate<is_nothrow_constructible,
> _Tp, _Alloc, _Args...>
> { };
>
>
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> inline constexpr bool
> __is_nothrow_uses_allocator_constructible_v =
> __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
>
>
> template<typename _Tp, typename... _Args>
> void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr,
> _Args&&... __args)
> { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
> _Args&&... __args)
> {
> ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
> _Args&&... __args)
> { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
> _Args&&... __args)
> {
> __uses_allocator_construct_impl(__use_alloc<_Tp, _Alloc, _Args...>(__a),
> __ptr, std::forward<_Args>(__args)...);
> }
>
>
>}
># 78 "/usr/include/c++/8/memory" 2 3
>
>
># 1 "/usr/include/c++/8/bits/unique_ptr.h" 1 3
># 37 "/usr/include/c++/8/bits/unique_ptr.h" 3
># 1 "/usr/include/c++/8/tuple" 1 3
># 32 "/usr/include/c++/8/tuple" 3
> 
># 33 "/usr/include/c++/8/tuple" 3
>
>
>
>
>
>
># 1 "/usr/include/c++/8/array" 1 3
># 32 "/usr/include/c++/8/array" 3
> 
># 33 "/usr/include/c++/8/array" 3
># 43 "/usr/include/c++/8/array" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, std::size_t _Nm>
> struct __array_traits
> {
> typedef _Tp _Type[_Nm];
> typedef __is_swappable<_Tp> _Is_swappable;
> typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
>
> static constexpr _Tp&
> _S_ref(const _Type& __t, std::size_t __n) noexcept
> { return const_cast<_Tp&>(__t[__n]); }
>
> static constexpr _Tp*
> _S_ptr(const _Type& __t) noexcept
> { return const_cast<_Tp*>(__t); }
> };
>
> template<typename _Tp>
> struct __array_traits<_Tp, 0>
> {
> struct _Type { };
> typedef true_type _Is_swappable;
> typedef true_type _Is_nothrow_swappable;
>
> static constexpr _Tp&
> _S_ref(const _Type&, std::size_t) noexcept
> { return *static_cast<_Tp*>(nullptr); }
>
> static constexpr _Tp*
> _S_ptr(const _Type&) noexcept
> { return nullptr; }
> };
># 93 "/usr/include/c++/8/array" 3
> template<typename _Tp, std::size_t _Nm>
> struct array
> {
> typedef _Tp value_type;
> typedef value_type* pointer;
> typedef const value_type* const_pointer;
> typedef value_type& reference;
> typedef const value_type& const_reference;
> typedef value_type* iterator;
> typedef const value_type* const_iterator;
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>
>
> typedef std::__array_traits<_Tp, _Nm> _AT_Type;
> typename _AT_Type::_Type _M_elems;
>
>
>
>
> void
> fill(const value_type& __u)
> { std::fill_n(begin(), size(), __u); }
>
> void
> swap(array& __other)
> noexcept(_AT_Type::_Is_nothrow_swappable::value)
> { std::swap_ranges(begin(), end(), __other.begin()); }
>
>
> constexpr iterator
> begin() noexcept
> { return iterator(data()); }
>
> constexpr const_iterator
> begin() const noexcept
> { return const_iterator(data()); }
>
> constexpr iterator
> end() noexcept
> { return iterator(data() + _Nm); }
>
> constexpr const_iterator
> end() const noexcept
> { return const_iterator(data() + _Nm); }
>
> constexpr reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> constexpr const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> constexpr reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> constexpr const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
> constexpr const_iterator
> cbegin() const noexcept
> { return const_iterator(data()); }
>
> constexpr const_iterator
> cend() const noexcept
> { return const_iterator(data() + _Nm); }
>
> constexpr const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> constexpr const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> constexpr size_type
> size() const noexcept { return _Nm; }
>
> constexpr size_type
> max_size() const noexcept { return _Nm; }
>
> constexpr bool
> empty() const noexcept { return size() == 0; }
>
>
> constexpr reference
> operator[](size_type __n) noexcept
> { return _AT_Type::_S_ref(_M_elems, __n); }
>
> constexpr const_reference
> operator[](size_type __n) const noexcept
> { return _AT_Type::_S_ref(_M_elems, __n); }
>
> constexpr reference
> at(size_type __n)
> {
> if (__n >= _Nm)
> std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
> ,
> __n, _Nm);
> return _AT_Type::_S_ref(_M_elems, __n);
> }
>
> constexpr const_reference
> at(size_type __n) const
> {
>
>
> return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
> : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
> ,
> __n, _Nm),
> _AT_Type::_S_ref(_M_elems, 0));
> }
>
> constexpr reference
> front() noexcept
> { return *begin(); }
>
> constexpr const_reference
> front() const noexcept
> { return _AT_Type::_S_ref(_M_elems, 0); }
>
> constexpr reference
> back() noexcept
> { return _Nm ? *(end() - 1) : *end(); }
>
> constexpr const_reference
> back() const noexcept
> {
> return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
> : _AT_Type::_S_ref(_M_elems, 0);
> }
>
> constexpr pointer
> data() noexcept
> { return _AT_Type::_S_ptr(_M_elems); }
>
> constexpr const_pointer
> data() const noexcept
> { return _AT_Type::_S_ptr(_M_elems); }
> };
>
>
> template<typename _Tp, typename... _Up>
> array(_Tp, _Up...)
> -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
> 1 + sizeof...(_Up)>;
>
>
>
> template<typename _Tp, std::size_t _Nm>
> inline bool
> operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
> { return std::equal(__one.begin(), __one.end(), __two.begin()); }
>
> template<typename _Tp, std::size_t _Nm>
> inline bool
> operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
> { return !(__one == __two); }
>
> template<typename _Tp, std::size_t _Nm>
> inline bool
> operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
> {
> return std::lexicographical_compare(__a.begin(), __a.end(),
> __b.begin(), __b.end());
> }
>
> template<typename _Tp, std::size_t _Nm>
> inline bool
> operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
> { return __two < __one; }
>
> template<typename _Tp, std::size_t _Nm>
> inline bool
> operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
> { return !(__one > __two); }
>
> template<typename _Tp, std::size_t _Nm>
> inline bool
> operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
> { return !(__one < __two); }
>
>
> template<typename _Tp, std::size_t _Nm>
> inline
>
>
> typename enable_if<
> std::__array_traits<_Tp, _Nm>::_Is_swappable::value
> >::type
>
>
>
> swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
> noexcept(noexcept(__one.swap(__two)))
> { __one.swap(__two); }
>
>
> template<typename _Tp, std::size_t _Nm>
> typename enable_if<
> !std::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
> swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
>
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr _Tp&
> get(array<_Tp, _Nm>& __arr) noexcept
> {
> static_assert(_Int < _Nm, "array index is within bounds");
> return std::__array_traits<_Tp, _Nm>::
> _S_ref(__arr._M_elems, _Int);
> }
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr _Tp&&
> get(array<_Tp, _Nm>&& __arr) noexcept
> {
> static_assert(_Int < _Nm, "array index is within bounds");
> return std::move(std::get<_Int>(__arr));
> }
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr const _Tp&
> get(const array<_Tp, _Nm>& __arr) noexcept
> {
> static_assert(_Int < _Nm, "array index is within bounds");
> return std::__array_traits<_Tp, _Nm>::
> _S_ref(__arr._M_elems, _Int);
> }
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr const _Tp&&
> get(const array<_Tp, _Nm>&& __arr) noexcept
> {
> static_assert(_Int < _Nm, "array index is within bounds");
> return std::move(std::get<_Int>(__arr));
> }
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
> template<typename _Tp>
> struct tuple_size;
>
>
> template<typename _Tp, std::size_t _Nm>
> struct tuple_size<std::array<_Tp, _Nm>>
> : public integral_constant<std::size_t, _Nm> { };
>
>
> template<std::size_t _Int, typename _Tp>
> struct tuple_element;
>
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> struct tuple_element<_Int, std::array<_Tp, _Nm>>
> {
> static_assert(_Int < _Nm, "index is out of bounds");
> typedef _Tp type;
> };
>
> template<typename _Tp, std::size_t _Nm>
> struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
> { };
>
>
>}
># 40 "/usr/include/c++/8/tuple" 2 3
>
># 1 "/usr/include/c++/8/bits/invoke.h" 1 3
># 33 "/usr/include/c++/8/bits/invoke.h" 3
> 
># 34 "/usr/include/c++/8/bits/invoke.h" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 52 "/usr/include/c++/8/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)...);
> }
>
>
>}
># 42 "/usr/include/c++/8/tuple" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename... _Elements>
> class tuple;
>
> template<typename _Tp>
> struct __is_empty_non_tuple : is_empty<_Tp> { };
>
>
> template<typename _El0, typename... _El>
> struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
>
>
> template<typename _Tp>
> using __empty_not_final
> = typename conditional<__is_final(_Tp), false_type,
> __is_empty_non_tuple<_Tp>>::type;
>
> template<std::size_t _Idx, typename _Head,
> bool = __empty_not_final<_Head>::value>
> struct _Head_base;
>
> template<std::size_t _Idx, typename _Head>
> struct _Head_base<_Idx, _Head, true>
> : public _Head
> {
> constexpr _Head_base()
> : _Head() { }
>
> constexpr _Head_base(const _Head& __h)
> : _Head(__h) { }
>
> constexpr _Head_base(const _Head_base&) = default;
> constexpr _Head_base(_Head_base&&) = default;
>
> template<typename _UHead>
> constexpr _Head_base(_UHead&& __h)
> : _Head(std::forward<_UHead>(__h)) { }
>
> _Head_base(allocator_arg_t, __uses_alloc0)
> : _Head() { }
>
> template<typename _Alloc>
> _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
> : _Head(allocator_arg, *__a._M_a) { }
>
> template<typename _Alloc>
> _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
> : _Head(*__a._M_a) { }
>
> template<typename _UHead>
> _Head_base(__uses_alloc0, _UHead&& __uhead)
> : _Head(std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
> : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
> : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
>
> static constexpr _Head&
> _M_head(_Head_base& __b) noexcept { return __b; }
>
> static constexpr const _Head&
> _M_head(const _Head_base& __b) noexcept { return __b; }
> };
>
> template<std::size_t _Idx, typename _Head>
> struct _Head_base<_Idx, _Head, false>
> {
> constexpr _Head_base()
> : _M_head_impl() { }
>
> constexpr _Head_base(const _Head& __h)
> : _M_head_impl(__h) { }
>
> constexpr _Head_base(const _Head_base&) = default;
> constexpr _Head_base(_Head_base&&) = default;
>
> template<typename _UHead>
> constexpr _Head_base(_UHead&& __h)
> : _M_head_impl(std::forward<_UHead>(__h)) { }
>
> _Head_base(allocator_arg_t, __uses_alloc0)
> : _M_head_impl() { }
>
> template<typename _Alloc>
> _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
> : _M_head_impl(allocator_arg, *__a._M_a) { }
>
> template<typename _Alloc>
> _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
> : _M_head_impl(*__a._M_a) { }
>
> template<typename _UHead>
> _Head_base(__uses_alloc0, _UHead&& __uhead)
> : _M_head_impl(std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
> : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
> { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
> : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
>
> static constexpr _Head&
> _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
>
> static constexpr const _Head&
> _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
>
> _Head _M_head_impl;
> };
># 176 "/usr/include/c++/8/tuple" 3
> template<std::size_t _Idx, typename... _Elements>
> struct _Tuple_impl;
>
>
>
>
>
>
> template<std::size_t _Idx, typename _Head, typename... _Tail>
> struct _Tuple_impl<_Idx, _Head, _Tail...>
> : public _Tuple_impl<_Idx + 1, _Tail...>,
> private _Head_base<_Idx, _Head>
> {
> template<std::size_t, typename...> friend class _Tuple_impl;
>
> typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
> typedef _Head_base<_Idx, _Head> _Base;
>
> static constexpr _Head&
> _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr const _Head&
> _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr _Inherited&
> _M_tail(_Tuple_impl& __t) noexcept { return __t; }
>
> static constexpr const _Inherited&
> _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
>
> constexpr _Tuple_impl()
> : _Inherited(), _Base() { }
>
> explicit
> constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
> : _Inherited(__tail...), _Base(__head) { }
>
> template<typename _UHead, typename... _UTail, typename = typename
> enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
> explicit
> constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
> : _Inherited(std::forward<_UTail>(__tail)...),
> _Base(std::forward<_UHead>(__head)) { }
>
> constexpr _Tuple_impl(const _Tuple_impl&) = default;
>
> constexpr
> _Tuple_impl(_Tuple_impl&& __in)
> noexcept(__and_<is_nothrow_move_constructible<_Head>,
> is_nothrow_move_constructible<_Inherited>>::value)
> : _Inherited(std::move(_M_tail(__in))),
> _Base(std::forward<_Head>(_M_head(__in))) { }
>
> template<typename... _UElements>
> constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
> : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
> _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
>
> template<typename _UHead, typename... _UTails>
> constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> : _Inherited(std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
> _Base(std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a),
> _Base(__tag, __use_alloc<_Head>(__a)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Head& __head, const _Tail&... __tail)
> : _Inherited(__tag, __a, __tail...),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
>
> template<typename _Alloc, typename _UHead, typename... _UTail,
> typename = typename enable_if<sizeof...(_Tail)
> == sizeof...(_UTail)>::type>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _UHead&& __head, _UTail&&... __tail)
> : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
> _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>(__head)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl& __in)
> : _Inherited(__tag, __a, _M_tail(__in)),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl&& __in)
> : _Inherited(__tag, __a, std::move(_M_tail(__in))),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> std::forward<_Head>(_M_head(__in))) { }
>
> template<typename _Alloc, typename... _UElements>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl<_Idx, _UElements...>& __in)
> : _Inherited(__tag, __a,
> _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
>
> template<typename _Alloc, typename _UHead, typename... _UTails>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> : _Inherited(__tag, __a, std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
> _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
>
> _Tuple_impl&
> operator=(const _Tuple_impl& __in)
> {
> _M_head(*this) = _M_head(__in);
> _M_tail(*this) = _M_tail(__in);
> return *this;
> }
>
> _Tuple_impl&
> operator=(_Tuple_impl&& __in)
> noexcept(__and_<is_nothrow_move_assignable<_Head>,
> is_nothrow_move_assignable<_Inherited>>::value)
> {
> _M_head(*this) = std::forward<_Head>(_M_head(__in));
> _M_tail(*this) = std::move(_M_tail(__in));
> return *this;
> }
>
> template<typename... _UElements>
> _Tuple_impl&
> operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
> {
> _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
> _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
> return *this;
> }
>
> template<typename _UHead, typename... _UTails>
> _Tuple_impl&
> operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> {
> _M_head(*this) = std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
> _M_tail(*this) = std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
> return *this;
> }
>
> protected:
> void
> _M_swap(_Tuple_impl& __in)
> noexcept(__is_nothrow_swappable<_Head>::value
> && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
> {
> using std::swap;
> swap(_M_head(*this), _M_head(__in));
> _Inherited::_M_swap(_M_tail(__in));
> }
> };
>
>
> template<std::size_t _Idx, typename _Head>
> struct _Tuple_impl<_Idx, _Head>
> : private _Head_base<_Idx, _Head>
> {
> template<std::size_t, typename...> friend class _Tuple_impl;
>
> typedef _Head_base<_Idx, _Head> _Base;
>
> static constexpr _Head&
> _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr const _Head&
> _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> constexpr _Tuple_impl()
> : _Base() { }
>
> explicit
> constexpr _Tuple_impl(const _Head& __head)
> : _Base(__head) { }
>
> template<typename _UHead>
> explicit
> constexpr _Tuple_impl(_UHead&& __head)
> : _Base(std::forward<_UHead>(__head)) { }
>
> constexpr _Tuple_impl(const _Tuple_impl&) = default;
>
> constexpr
> _Tuple_impl(_Tuple_impl&& __in)
> noexcept(is_nothrow_move_constructible<_Head>::value)
> : _Base(std::forward<_Head>(_M_head(__in))) { }
>
> template<typename _UHead>
> constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
> : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
>
> template<typename _UHead>
> constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
> : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
> { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
> : _Base(__tag, __use_alloc<_Head>(__a)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Head& __head)
> : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
>
> template<typename _Alloc, typename _UHead>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _UHead&& __head)
> : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>(__head)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl& __in)
> : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl&& __in)
> : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> std::forward<_Head>(_M_head(__in))) { }
>
> template<typename _Alloc, typename _UHead>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl<_Idx, _UHead>& __in)
> : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
>
> template<typename _Alloc, typename _UHead>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl<_Idx, _UHead>&& __in)
> : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
> { }
>
> _Tuple_impl&
> operator=(const _Tuple_impl& __in)
> {
> _M_head(*this) = _M_head(__in);
> return *this;
> }
>
> _Tuple_impl&
> operator=(_Tuple_impl&& __in)
> noexcept(is_nothrow_move_assignable<_Head>::value)
> {
> _M_head(*this) = std::forward<_Head>(_M_head(__in));
> return *this;
> }
>
> template<typename _UHead>
> _Tuple_impl&
> operator=(const _Tuple_impl<_Idx, _UHead>& __in)
> {
> _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
> return *this;
> }
>
> template<typename _UHead>
> _Tuple_impl&
> operator=(_Tuple_impl<_Idx, _UHead>&& __in)
> {
> _M_head(*this)
> = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
> return *this;
> }
>
> protected:
> void
> _M_swap(_Tuple_impl& __in)
> noexcept(__is_nothrow_swappable<_Head>::value)
> {
> using std::swap;
> swap(_M_head(*this), _M_head(__in));
> }
> };
>
>
>
> template<bool, typename... _Elements>
> struct _TC
> {
> template<typename... _UElements>
> static constexpr bool _ConstructibleTuple()
> {
> return __and_<is_constructible<_Elements, const _UElements&>...>::value;
> }
>
> template<typename... _UElements>
> static constexpr bool _ImplicitlyConvertibleTuple()
> {
> return __and_<is_convertible<const _UElements&, _Elements>...>::value;
> }
>
> template<typename... _UElements>
> static constexpr bool _MoveConstructibleTuple()
> {
> return __and_<is_constructible<_Elements, _UElements&&>...>::value;
> }
>
> template<typename... _UElements>
> static constexpr bool _ImplicitlyMoveConvertibleTuple()
> {
> return __and_<is_convertible<_UElements&&, _Elements>...>::value;
> }
>
> template<typename _SrcTuple>
> static constexpr bool _NonNestedTuple()
> {
> return __and_<__not_<is_same<tuple<_Elements...>,
> typename remove_cv<
> typename remove_reference<_SrcTuple>::type
> >::type>>,
> __not_<is_convertible<_SrcTuple, _Elements...>>,
> __not_<is_constructible<_Elements..., _SrcTuple>>
> >::value;
> }
> template<typename... _UElements>
> static constexpr bool _NotSameTuple()
> {
> return __not_<is_same<tuple<_Elements...>,
> typename remove_const<
> typename remove_reference<_UElements...>::type
> >::type>>::value;
> }
> };
>
> template<typename... _Elements>
> struct _TC<false, _Elements...>
> {
> template<typename... _UElements>
> static constexpr bool _ConstructibleTuple()
> {
> return false;
> }
>
> template<typename... _UElements>
> static constexpr bool _ImplicitlyConvertibleTuple()
> {
> return false;
> }
>
> template<typename... _UElements>
> static constexpr bool _MoveConstructibleTuple()
> {
> return false;
> }
>
> template<typename... _UElements>
> static constexpr bool _ImplicitlyMoveConvertibleTuple()
> {
> return false;
> }
>
> template<typename... _UElements>
> static constexpr bool _NonNestedTuple()
> {
> return true;
> }
> template<typename... _UElements>
> static constexpr bool _NotSameTuple()
> {
> return true;
> }
> };
>
>
> template<typename... _Elements>
> class tuple : public _Tuple_impl<0, _Elements...>
> {
> typedef _Tuple_impl<0, _Elements...> _Inherited;
>
>
>
> template<typename _Dummy>
> struct _TC2
> {
> static constexpr bool _DefaultConstructibleTuple()
> {
> return __and_<is_default_constructible<_Elements>...>::value;
> }
> static constexpr bool _ImplicitlyDefaultConstructibleTuple()
> {
> return __and_<__is_implicitly_default_constructible<_Elements>...>
> ::value;
> }
> };
>
> public:
> template<typename _Dummy = void,
> typename enable_if<_TC2<_Dummy>::
> _ImplicitlyDefaultConstructibleTuple(),
> bool>::type = true>
> constexpr tuple()
> : _Inherited() { }
>
> template<typename _Dummy = void,
> typename enable_if<_TC2<_Dummy>::
> _DefaultConstructibleTuple()
> &&
> !_TC2<_Dummy>::
> _ImplicitlyDefaultConstructibleTuple(),
> bool>::type = false>
> explicit constexpr tuple()
> : _Inherited() { }
>
>
>
> template<typename _Dummy> using _TCC =
> _TC<is_same<_Dummy, void>::value,
> _Elements...>;
>
> template<typename _Dummy = void,
> typename enable_if<
> _TCC<_Dummy>::template
> _ConstructibleTuple<_Elements...>()
> && _TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_Elements...>()
> && (sizeof...(_Elements) >= 1),
> bool>::type=true>
> constexpr tuple(const _Elements&... __elements)
> : _Inherited(__elements...) { }
>
> template<typename _Dummy = void,
> typename enable_if<
> _TCC<_Dummy>::template
> _ConstructibleTuple<_Elements...>()
> && !_TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_Elements...>()
> && (sizeof...(_Elements) >= 1),
> bool>::type=false>
> explicit constexpr tuple(const _Elements&... __elements)
> : _Inherited(__elements...) { }
>
>
>
> template<typename... _UElements> using _TMC =
> _TC<(sizeof...(_Elements) == sizeof...(_UElements))
> && (_TC<(sizeof...(_UElements)==1), _Elements...>::
> template _NotSameTuple<_UElements...>()),
> _Elements...>;
>
>
>
> template<typename... _UElements> using _TMCT =
> _TC<(sizeof...(_Elements) == sizeof...(_UElements))
> && !is_same<tuple<_Elements...>,
> tuple<_UElements...>>::value,
> _Elements...>;
>
> template<typename... _UElements, typename
> enable_if<
> _TMC<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && _TMC<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>()
> && (sizeof...(_Elements) >= 1),
> bool>::type=true>
> constexpr tuple(_UElements&&... __elements)
> : _Inherited(std::forward<_UElements>(__elements)...) { }
>
> template<typename... _UElements, typename
> enable_if<
> _TMC<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && !_TMC<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>()
> && (sizeof...(_Elements) >= 1),
> bool>::type=false>
> explicit constexpr tuple(_UElements&&... __elements)
> : _Inherited(std::forward<_UElements>(__elements)...) { }
>
> constexpr tuple(const tuple&) = default;
>
> constexpr tuple(tuple&&) = default;
>
>
>
> template<typename _Dummy> using _TNTC =
> _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
> _Elements...>;
>
> template<typename... _UElements, typename _Dummy = void, typename
> enable_if<_TMCT<_UElements...>::template
> _ConstructibleTuple<_UElements...>()
> && _TMCT<_UElements...>::template
> _ImplicitlyConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<const tuple<_UElements...>&>(),
> bool>::type=true>
> constexpr tuple(const tuple<_UElements...>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename... _UElements, typename _Dummy = void, typename
> enable_if<_TMCT<_UElements...>::template
> _ConstructibleTuple<_UElements...>()
> && !_TMCT<_UElements...>::template
> _ImplicitlyConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<const tuple<_UElements...>&>(),
> bool>::type=false>
> explicit constexpr tuple(const tuple<_UElements...>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename... _UElements, typename _Dummy = void, typename
> enable_if<_TMCT<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && _TMCT<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<tuple<_UElements...>&&>(),
> bool>::type=true>
> constexpr tuple(tuple<_UElements...>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
>
> template<typename... _UElements, typename _Dummy = void, typename
> enable_if<_TMCT<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && !_TMCT<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<tuple<_UElements...>&&>(),
> bool>::type=false>
> explicit constexpr tuple(tuple<_UElements...>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
>
>
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a) { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename enable_if<
> _TCC<_Dummy>::template
> _ConstructibleTuple<_Elements...>()
> && _TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_Elements...>(),
> bool>::type=true>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _Elements&... __elements)
> : _Inherited(__tag, __a, __elements...) { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename enable_if<
> _TCC<_Dummy>::template
> _ConstructibleTuple<_Elements...>()
> && !_TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_Elements...>(),
> bool>::type=false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _Elements&... __elements)
> : _Inherited(__tag, __a, __elements...) { }
>
> template<typename _Alloc, typename... _UElements, typename
> enable_if<_TMC<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && _TMC<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>(),
> bool>::type=true>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> _UElements&&... __elements)
> : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
> { }
>
> template<typename _Alloc, typename... _UElements, typename
> enable_if<_TMC<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && !_TMC<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>(),
> bool>::type=false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> _UElements&&... __elements)
> : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
> { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
> : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
> : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename... _UElements, typename
> enable_if<_TMCT<_UElements...>::template
> _ConstructibleTuple<_UElements...>()
> && _TMCT<_UElements...>::template
> _ImplicitlyConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<tuple<_UElements...>&&>(),
> bool>::type=true>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_UElements...>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename... _UElements, typename
> enable_if<_TMCT<_UElements...>::template
> _ConstructibleTuple<_UElements...>()
> && !_TMCT<_UElements...>::template
> _ImplicitlyConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<tuple<_UElements...>&&>(),
> bool>::type=false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_UElements...>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename... _UElements, typename
> enable_if<_TMCT<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && _TMCT<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<tuple<_UElements...>&&>(),
> bool>::type=true>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> tuple<_UElements...>&& __in)
> : _Inherited(__tag, __a,
> static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
> { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename... _UElements, typename
> enable_if<_TMCT<_UElements...>::template
> _MoveConstructibleTuple<_UElements...>()
> && !_TMCT<_UElements...>::template
> _ImplicitlyMoveConvertibleTuple<_UElements...>()
> && _TNTC<_Dummy>::template
> _NonNestedTuple<tuple<_UElements...>&&>(),
> bool>::type=false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> tuple<_UElements...>&& __in)
> : _Inherited(__tag, __a,
> static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
> { }
>
> tuple&
> operator=(const tuple& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> tuple&
> operator=(tuple&& __in)
> noexcept(is_nothrow_move_assignable<_Inherited>::value)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename... _UElements>
> typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements), tuple&>::type
> operator=(const tuple<_UElements...>& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> template<typename... _UElements>
> typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements), tuple&>::type
> operator=(tuple<_UElements...>&& __in)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> void
> swap(tuple& __in)
> noexcept(noexcept(__in._M_swap(__in)))
> { _Inherited::_M_swap(__in); }
> };
>
>
> template<typename... _UTypes>
> tuple(_UTypes...) -> tuple<_UTypes...>;
> template<typename _T1, typename _T2>
> tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
> template<typename _Alloc, typename... _UTypes>
> tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
> template<typename _Alloc, typename _T1, typename _T2>
> tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
> template<typename _Alloc, typename... _UTypes>
> tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
>
>
>
> template<>
> class tuple<>
> {
> public:
> void swap(tuple&) noexcept { }
>
>
> tuple() = default;
>
> template<typename _Alloc>
> tuple(allocator_arg_t, const _Alloc&) { }
> template<typename _Alloc>
> tuple(allocator_arg_t, const _Alloc&, const tuple&) { }
> };
>
>
>
> template<typename _T1, typename _T2>
> class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
> {
> typedef _Tuple_impl<0, _T1, _T2> _Inherited;
>
> public:
> template <typename _U1 = _T1,
> typename _U2 = _T2,
> typename enable_if<__and_<
> __is_implicitly_default_constructible<_U1>,
> __is_implicitly_default_constructible<_U2>>
> ::value, bool>::type = true>
>
> constexpr tuple()
> : _Inherited() { }
>
> template <typename _U1 = _T1,
> typename _U2 = _T2,
> typename enable_if<
> __and_<
> is_default_constructible<_U1>,
> is_default_constructible<_U2>,
> __not_<
> __and_<__is_implicitly_default_constructible<_U1>,
> __is_implicitly_default_constructible<_U2>>>>
> ::value, bool>::type = false>
>
> explicit constexpr tuple()
> : _Inherited() { }
>
>
>
> template<typename _Dummy> using _TCC =
> _TC<is_same<_Dummy, void>::value, _T1, _T2>;
>
> template<typename _Dummy = void, typename
> enable_if<_TCC<_Dummy>::template
> _ConstructibleTuple<_T1, _T2>()
> && _TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_T1, _T2>(),
> bool>::type = true>
> constexpr tuple(const _T1& __a1, const _T2& __a2)
> : _Inherited(__a1, __a2) { }
>
> template<typename _Dummy = void, typename
> enable_if<_TCC<_Dummy>::template
> _ConstructibleTuple<_T1, _T2>()
> && !_TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_T1, _T2>(),
> bool>::type = false>
> explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
> : _Inherited(__a1, __a2) { }
>
>
>
> using _TMC = _TC<true, _T1, _T2>;
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
> && !is_same<typename decay<_U1>::type,
> allocator_arg_t>::value,
> bool>::type = true>
> constexpr tuple(_U1&& __a1, _U2&& __a2)
> : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
> && !is_same<typename decay<_U1>::type,
> allocator_arg_t>::value,
> bool>::type = false>
> explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
> : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
>
> constexpr tuple(const tuple&) = default;
>
> constexpr tuple(tuple&&) = default;
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> constexpr tuple(const tuple<_U1, _U2>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit constexpr tuple(const tuple<_U1, _U2>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> constexpr tuple(tuple<_U1, _U2>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit constexpr tuple(tuple<_U1, _U2>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> constexpr tuple(const pair<_U1, _U2>& __in)
> : _Inherited(__in.first, __in.second) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit constexpr tuple(const pair<_U1, _U2>& __in)
> : _Inherited(__in.first, __in.second) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> constexpr tuple(pair<_U1, _U2>&& __in)
> : _Inherited(std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
> template<typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit constexpr tuple(pair<_U1, _U2>&& __in)
> : _Inherited(std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
>
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a) { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename enable_if<
> _TCC<_Dummy>::template
> _ConstructibleTuple<_T1, _T2>()
> && _TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_T1, _T2>(),
> bool>::type=true>
>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _T1& __a1, const _T2& __a2)
> : _Inherited(__tag, __a, __a1, __a2) { }
>
> template<typename _Alloc, typename _Dummy = void,
> typename enable_if<
> _TCC<_Dummy>::template
> _ConstructibleTuple<_T1, _T2>()
> && !_TCC<_Dummy>::template
> _ImplicitlyConvertibleTuple<_T1, _T2>(),
> bool>::type=false>
>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _T1& __a1, const _T2& __a2)
> : _Inherited(__tag, __a, __a1, __a2) { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
> : _Inherited(__tag, __a, std::forward<_U1>(__a1),
> std::forward<_U2>(__a2)) { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> _U1&& __a1, _U2&& __a2)
> : _Inherited(__tag, __a, std::forward<_U1>(__a1),
> std::forward<_U2>(__a2)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
> : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
> : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_U1, _U2>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_U1, _U2>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> tuple<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const pair<_U1, _U2>& __in)
> : _Inherited(__tag, __a, __in.first, __in.second) { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _ConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> const pair<_U1, _U2>& __in)
> : _Inherited(__tag, __a, __in.first, __in.second) { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && _TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = true>
> tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
> template<typename _Alloc, typename _U1, typename _U2, typename
> enable_if<_TMC::template
> _MoveConstructibleTuple<_U1, _U2>()
> && !_TMC::template
> _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
> bool>::type = false>
> explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
> pair<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
> tuple&
> operator=(const tuple& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> tuple&
> operator=(tuple&& __in)
> noexcept(is_nothrow_move_assignable<_Inherited>::value)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(const tuple<_U1, _U2>& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(tuple<_U1, _U2>&& __in)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(const pair<_U1, _U2>& __in)
> {
> this->_M_head(*this) = __in.first;
> this->_M_tail(*this)._M_head(*this) = __in.second;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(pair<_U1, _U2>&& __in)
> {
> this->_M_head(*this) = std::forward<_U1>(__in.first);
> this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
> return *this;
> }
>
> void
> swap(tuple& __in)
> noexcept(noexcept(__in._M_swap(__in)))
> { _Inherited::_M_swap(__in); }
> };
>
>
>
> template<typename... _Elements>
> struct tuple_size<tuple<_Elements...>>
> : public integral_constant<std::size_t, sizeof...(_Elements)> { };
>
>
> template <typename _Tp>
> inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
>
>
>
>
>
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> struct tuple_element<__i, tuple<_Head, _Tail...> >
> : tuple_element<__i - 1, tuple<_Tail...> > { };
>
>
>
>
> template<typename _Head, typename... _Tail>
> struct tuple_element<0, tuple<_Head, _Tail...> >
> {
> typedef _Head type;
> };
>
>
>
>
> template<size_t __i>
> struct tuple_element<__i, tuple<>>
> {
> static_assert(__i < tuple_size<tuple<>>::value,
> "tuple index is in range");
> };
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> constexpr _Head&
> __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> constexpr const _Head&
> __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
>
> template<std::size_t __i, typename... _Elements>
> constexpr __tuple_element_t<__i, tuple<_Elements...>>&
> get(tuple<_Elements...>& __t) noexcept
> { return std::__get_helper<__i>(__t); }
>
>
> template<std::size_t __i, typename... _Elements>
> constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
> get(const tuple<_Elements...>& __t) noexcept
> { return std::__get_helper<__i>(__t); }
>
>
> template<std::size_t __i, typename... _Elements>
> constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
> get(tuple<_Elements...>&& __t) noexcept
> {
> typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
> return std::forward<__element_type&&>(std::get<__i>(__t));
> }
>
>
> template<std::size_t __i, typename... _Elements>
> constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
> get(const tuple<_Elements...>&& __t) noexcept
> {
> typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
> return std::forward<const __element_type&&>(std::get<__i>(__t));
> }
>
>
>
>
>
> template<typename _Head, size_t __i, typename... _Tail>
> constexpr _Head&
> __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
> template<typename _Head, size_t __i, typename... _Tail>
> constexpr const _Head&
> __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
>
> template <typename _Tp, typename... _Types>
> constexpr _Tp&
> get(tuple<_Types...>& __t) noexcept
> { return std::__get_helper2<_Tp>(__t); }
>
>
> template <typename _Tp, typename... _Types>
> constexpr _Tp&&
> get(tuple<_Types...>&& __t) noexcept
> { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
>
>
> template <typename _Tp, typename... _Types>
> constexpr const _Tp&
> get(const tuple<_Types...>& __t) noexcept
> { return std::__get_helper2<_Tp>(__t); }
>
>
>
> template <typename _Tp, typename... _Types>
> constexpr const _Tp&&
> get(const tuple<_Types...>&& __t) noexcept
> { return std::forward<const _Tp&&>(std::__get_helper2<_Tp>(__t)); }
>
>
>
> template<typename _Tp, typename _Up, size_t __i, size_t __size>
> struct __tuple_compare
> {
> static constexpr bool
> __eq(const _Tp& __t, const _Up& __u)
> {
> return bool(std::get<__i>(__t) == std::get<__i>(__u))
> && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
> }
>
> static constexpr bool
> __less(const _Tp& __t, const _Up& __u)
> {
> return bool(std::get<__i>(__t) < std::get<__i>(__u))
> || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
> && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
> }
> };
>
> template<typename _Tp, typename _Up, size_t __size>
> struct __tuple_compare<_Tp, _Up, __size, __size>
> {
> static constexpr bool
> __eq(const _Tp&, const _Up&) { return true; }
>
> static constexpr bool
> __less(const _Tp&, const _Up&) { return false; }
> };
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator==(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> {
> static_assert(sizeof...(_TElements) == sizeof...(_UElements),
> "tuple objects can only be compared if they have equal sizes.");
> using __compare = __tuple_compare<tuple<_TElements...>,
> tuple<_UElements...>,
> 0, sizeof...(_TElements)>;
> return __compare::__eq(__t, __u);
> }
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator<(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> {
> static_assert(sizeof...(_TElements) == sizeof...(_UElements),
> "tuple objects can only be compared if they have equal sizes.");
> using __compare = __tuple_compare<tuple<_TElements...>,
> tuple<_UElements...>,
> 0, sizeof...(_TElements)>;
> return __compare::__less(__t, __u);
> }
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator!=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__t == __u); }
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator>(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return __u < __t; }
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator<=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__u < __t); }
>
> template<typename... _TElements, typename... _UElements>
> constexpr bool
> operator>=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__t < __u); }
>
>
> template<typename... _Elements>
> constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
> make_tuple(_Elements&&... __args)
> {
> typedef tuple<typename __decay_and_strip<_Elements>::__type...>
> __result_type;
> return __result_type(std::forward<_Elements>(__args)...);
> }
>
>
>
> template<typename... _Elements>
> constexpr tuple<_Elements&&...>
> forward_as_tuple(_Elements&&... __args) noexcept
> { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
>
> template<size_t, typename, typename, size_t>
> struct __make_tuple_impl;
>
> template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
> struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
> : __make_tuple_impl<_Idx + 1,
> tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
> _Tuple, _Nm>
> { };
>
> template<std::size_t _Nm, typename _Tuple, typename... _Tp>
> struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
> {
> typedef tuple<_Tp...> __type;
> };
>
> template<typename _Tuple>
> struct __do_make_tuple
> : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
> { };
>
>
> template<typename _Tuple>
> struct __make_tuple
> : public __do_make_tuple<typename std::remove_cv
> <typename std::remove_reference<_Tuple>::type>::type>
> { };
>
>
> template<typename...>
> struct __combine_tuples;
>
> template<>
> struct __combine_tuples<>
> {
> typedef tuple<> __type;
> };
>
> template<typename... _Ts>
> struct __combine_tuples<tuple<_Ts...>>
> {
> typedef tuple<_Ts...> __type;
> };
>
> template<typename... _T1s, typename... _T2s, typename... _Rem>
> struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
> {
> typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
> _Rem...>::__type __type;
> };
>
>
> template<typename... _Tpls>
> struct __tuple_cat_result
> {
> typedef typename __combine_tuples
> <typename __make_tuple<_Tpls>::__type...>::__type __type;
> };
>
>
>
> template<typename...>
> struct __make_1st_indices;
>
> template<>
> struct __make_1st_indices<>
> {
> typedef std::_Index_tuple<> __type;
> };
>
> template<typename _Tp, typename... _Tpls>
> struct __make_1st_indices<_Tp, _Tpls...>
> {
> typedef typename std::_Build_index_tuple<std::tuple_size<
> typename std::remove_reference<_Tp>::type>::value>::__type __type;
> };
>
>
>
>
> template<typename _Ret, typename _Indices, typename... _Tpls>
> struct __tuple_concater;
>
> template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
> struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
> {
> template<typename... _Us>
> static constexpr _Ret
> _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
> {
> typedef typename __make_1st_indices<_Tpls...>::__type __idx;
> typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
> return __next::_S_do(std::forward<_Tpls>(__tps)...,
> std::forward<_Us>(__us)...,
> std::get<_Is>(std::forward<_Tp>(__tp))...);
> }
> };
>
> template<typename _Ret>
> struct __tuple_concater<_Ret, std::_Index_tuple<>>
> {
> template<typename... _Us>
> static constexpr _Ret
> _S_do(_Us&&... __us)
> {
> return _Ret(std::forward<_Us>(__us)...);
> }
> };
>
>
> template<typename... _Tpls, typename = typename
> enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
> constexpr auto
> tuple_cat(_Tpls&&... __tpls)
> -> typename __tuple_cat_result<_Tpls...>::__type
> {
> typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
> typedef typename __make_1st_indices<_Tpls...>::__type __idx;
> typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
> return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
> }
>
>
>
>
> template<typename... _Elements>
> constexpr tuple<_Elements&...>
> tie(_Elements&... __args) noexcept
> { return tuple<_Elements&...>(__args...); }
>
>
> template<typename... _Elements>
> inline
>
>
> typename enable_if<__and_<__is_swappable<_Elements>...>::value
> >::type
>
>
>
> swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
> template<typename... _Elements>
> typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
> swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
>
>
>
>
>
>
> struct _Swallow_assign
> {
> template<class _Tp>
> constexpr const _Swallow_assign&
> operator=(const _Tp&) const
> { return *this; }
> };
>
>
>
> inline constexpr _Swallow_assign ignore{};
>
>
> template<typename... _Types, typename _Alloc>
> struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
>
>
> template<class _T1, class _T2>
> template<typename... _Args1, typename... _Args2>
> inline
> pair<_T1, _T2>::
> pair(piecewise_construct_t,
> tuple<_Args1...> __first, tuple<_Args2...> __second)
> : pair(__first, __second,
> typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
> typename _Build_index_tuple<sizeof...(_Args2)>::__type())
> { }
>
> template<class _T1, class _T2>
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
> inline
> pair<_T1, _T2>::
> pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
> : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
> second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
> { }
>
>
>
>
> template <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)
> {
> using _Indices = make_index_sequence<tuple_size_v<decay_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)
> {
> return __make_from_tuple_impl<_Tp>(
> std::forward<_Tuple>(__t),
> make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{});
> }
>
>
>
>
>
>}
># 38 "/usr/include/c++/8/bits/unique_ptr.h" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
> template<typename> class auto_ptr;
>#pragma GCC diagnostic pop
>
>
>
> template<typename _Tp>
> struct default_delete
> {
>
> constexpr default_delete() noexcept = default;
>
>
>
>
>
>
> template<typename _Up, typename = typename
> enable_if<is_convertible<_Up*, _Tp*>::value>::type>
> default_delete(const default_delete<_Up>&) noexcept { }
>
>
> void
> operator()(_Tp* __ptr) const
> {
> static_assert(!is_void<_Tp>::value,
> "can't delete pointer to incomplete type");
> static_assert(sizeof(_Tp)>0,
> "can't delete pointer to incomplete type");
> delete __ptr;
> }
> };
>
>
>
>
> template<typename _Tp>
> struct default_delete<_Tp[]>
> {
> public:
>
> constexpr default_delete() noexcept = default;
># 104 "/usr/include/c++/8/bits/unique_ptr.h" 3
> template<typename _Up, typename = typename
> enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
> 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;
>
> __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)) { }
>
> pointer& _M_ptr() { return std::get<0>(_M_t); }
> pointer _M_ptr() const { return std::get<0>(_M_t); }
> _Dp& _M_deleter() { return std::get<1>(_M_t); }
> const _Dp& _M_deleter() const { return std::get<1>(_M_t); }
>
> private:
> tuple<pointer, _Dp> _M_t;
> };
>
>
> template <typename _Tp, typename _Dp = default_delete<_Tp>>
> class unique_ptr
> {
> template <class _Up>
> using _DeleterConstraint =
> typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
>
> __uniq_ptr_impl<_Tp, _Dp> _M_t;
>
> public:
> using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
> using element_type = _Tp;
> using deleter_type = _Dp;
>
>
>
> template<typename _Up, typename _Ep>
> using __safe_conversion_up = __and_<
> is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
> __not_<is_array<_Up>>,
> __or_<__and_<is_reference<deleter_type>,
> is_same<deleter_type, _Ep>>,
> __and_<__not_<is_reference<deleter_type>>,
> is_convertible<_Ep, deleter_type>>
> >
> >;
>
>
>
>
> template <typename _Up = _Dp,
> typename = _DeleterConstraint<_Up>>
> constexpr unique_ptr() noexcept
> : _M_t()
> { }
>
>
>
>
>
>
>
> template <typename _Up = _Dp,
> typename = _DeleterConstraint<_Up>>
> explicit
> unique_ptr(pointer __p) noexcept
> : _M_t(__p)
> { }
># 215 "/usr/include/c++/8/bits/unique_ptr.h" 3
> unique_ptr(pointer __p,
> typename conditional<is_reference<deleter_type>::value,
> deleter_type, const deleter_type&>::type __d) noexcept
> : _M_t(__p, __d) { }
># 227 "/usr/include/c++/8/bits/unique_ptr.h" 3
> unique_ptr(pointer __p,
> typename remove_reference<deleter_type>::type&& __d) noexcept
> : _M_t(std::move(__p), std::move(__d))
> { static_assert(!std::is_reference<deleter_type>::value,
> "rvalue deleter bound to reference"); }
>
>
> template <typename _Up = _Dp,
> typename = _DeleterConstraint<_Up>>
> constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
>
>
>
>
> unique_ptr(unique_ptr&& __u) noexcept
> : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
>
>
>
>
>
>
>
> template<typename _Up, typename _Ep, typename = _Require<
> __safe_conversion_up<_Up, _Ep>,
> typename conditional<is_reference<_Dp>::value,
> is_same<_Ep, _Dp>,
> is_convertible<_Ep, _Dp>>::type>>
> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
> : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
> { }
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
>
> template<typename _Up, typename = _Require<
> is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
> unique_ptr(auto_ptr<_Up>&& __u) noexcept;
>#pragma GCC diagnostic pop
>
>
>
> ~unique_ptr() noexcept
> {
> auto& __ptr = _M_t._M_ptr();
> if (__ptr != nullptr)
> get_deleter()(__ptr);
> __ptr = pointer();
> }
># 286 "/usr/include/c++/8/bits/unique_ptr.h" 3
> unique_ptr&
> operator=(unique_ptr&& __u) noexcept
> {
> reset(__u.release());
> get_deleter() = std::forward<deleter_type>(__u.get_deleter());
> return *this;
> }
># 301 "/usr/include/c++/8/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
> {
> ;
> 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
> {
> pointer __p = get();
> _M_t._M_ptr() = pointer();
> return __p;
> }
>
>
>
>
>
>
>
> void
> reset(pointer __p = pointer()) noexcept
> {
> using std::swap;
> swap(_M_t._M_ptr(), __p);
> if (__p != pointer())
> get_deleter()(__p);
> }
>
>
> void
> swap(unique_ptr& __u) noexcept
> {
> using std::swap;
> swap(_M_t, __u._M_t);
> }
>
>
> unique_ptr(const unique_ptr&) = delete;
> unique_ptr& operator=(const unique_ptr&) = delete;
> };
>
>
>
>
>
> template<typename _Tp, typename _Dp>
> class unique_ptr<_Tp[], _Dp>
> {
> template <typename _Up>
> using _DeleterConstraint =
> typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
>
> __uniq_ptr_impl<_Tp, _Dp> _M_t;
>
> template<typename _Up>
> using __remove_cv = typename remove_cv<_Up>::type;
>
>
> template<typename _Up>
> using __is_derived_Tp
> = __and_< is_base_of<_Tp, _Up>,
> __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
>
> public:
> using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
> using element_type = _Tp;
> using deleter_type = _Dp;
>
>
>
> template<typename _Up, typename _Ep,
> typename _Up_up = unique_ptr<_Up, _Ep>,
> typename _Up_element_type = typename _Up_up::element_type>
> using __safe_conversion_up = __and_<
> is_array<_Up>,
> is_same<pointer, element_type*>,
> is_same<typename _Up_up::pointer, _Up_element_type*>,
> is_convertible<_Up_element_type(*)[], element_type(*)[]>,
> __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
> __and_<__not_<is_reference<deleter_type>>,
> is_convertible<_Ep, deleter_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 _Up = _Dp,
> typename = _DeleterConstraint<_Up>>
> constexpr unique_ptr() noexcept
> : _M_t()
> { }
># 470 "/usr/include/c++/8/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)
> { }
># 488 "/usr/include/c++/8/bits/unique_ptr.h" 3
> template<typename _Up,
> typename = typename enable_if<
> __safe_conversion_raw<_Up>::value, bool>::type>
> unique_ptr(_Up __p,
> typename conditional<is_reference<deleter_type>::value,
> deleter_type, const deleter_type&>::type __d) noexcept
> : _M_t(__p, __d) { }
># 504 "/usr/include/c++/8/bits/unique_ptr.h" 3
> template<typename _Up,
> typename = typename enable_if<
> __safe_conversion_raw<_Up>::value, bool>::type>
> unique_ptr(_Up __p, typename
> remove_reference<deleter_type>::type&& __d) noexcept
> : _M_t(std::move(__p), std::move(__d))
> { static_assert(!is_reference<deleter_type>::value,
> "rvalue deleter bound to reference"); }
>
>
> unique_ptr(unique_ptr&& __u) noexcept
> : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
>
>
> template <typename _Up = _Dp,
> typename = _DeleterConstraint<_Up>>
> constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
>
> template<typename _Up, typename _Ep,
> typename = _Require<__safe_conversion_up<_Up, _Ep>>>
> 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();
> }
># 545 "/usr/include/c++/8/bits/unique_ptr.h" 3
> unique_ptr&
> operator=(unique_ptr&& __u) noexcept
> {
> reset(__u.release());
> get_deleter() = std::forward<deleter_type>(__u.get_deleter());
> return *this;
> }
># 560 "/usr/include/c++/8/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
> {
> ;
> 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
> {
> pointer __p = get();
> _M_t._M_ptr() = pointer();
> return __p;
> }
>
>
>
>
>
>
>
> 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
> {
> pointer __ptr = __p;
> using std::swap;
> swap(_M_t._M_ptr(), __ptr);
> if (__ptr != nullptr)
> get_deleter()(__ptr);
> }
>
> void reset(nullptr_t = nullptr) noexcept
> {
> reset(pointer());
> }
>
>
> void
> swap(unique_ptr& __u) noexcept
> {
> using std::swap;
> swap(_M_t, __u._M_t);
> }
>
>
> unique_ptr(const unique_ptr&) = delete;
> unique_ptr& operator=(const unique_ptr&) = delete;
> };
>
> template<typename _Tp, typename _Dp>
> inline
>
>
> typename enable_if<__is_swappable<_Dp>::value>::type
>
>
>
> swap(unique_ptr<_Tp, _Dp>& __x,
> unique_ptr<_Tp, _Dp>& __y) noexcept
> { __x.swap(__y); }
>
>
> template<typename _Tp, typename _Dp>
> typename enable_if<!__is_swappable<_Dp>::value>::type
> swap(unique_ptr<_Tp, _Dp>&,
> unique_ptr<_Tp, _Dp>&) = delete;
>
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> 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>
> inline bool
> operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
> { return !__x; }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
> { return !__x; }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> 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>
> inline bool
> operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
> { return (bool)__x; }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
> { return (bool)__x; }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> 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>
> 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>
> 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>
> inline bool
> operator<=(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return !(__y < __x); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
> { return !(nullptr < __x); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
> { return !(__x < nullptr); }
>
> template<typename _Tp, typename _Dp,
> typename _Up, typename _Ep>
> inline bool
> operator>(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return (__y < __x); }
>
> template<typename _Tp, typename _Dp>
> 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>
> 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>
> inline bool
> operator>=(const unique_ptr<_Tp, _Dp>& __x,
> const unique_ptr<_Up, _Ep>& __y)
> { return !(__x < __y); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
> { return !(__x < nullptr); }
>
> template<typename _Tp, typename _Dp>
> inline bool
> operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
> { return !(nullptr < __x); }
>
>
> template<typename _Tp, typename _Dp>
> struct hash<unique_ptr<_Tp, _Dp>>
> : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
> private __poison_hash<typename unique_ptr<_Tp, _Dp>::pointer>
> {
> size_t
> operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
> {
> typedef unique_ptr<_Tp, _Dp> _UP;
> return std::hash<typename _UP::pointer>()(__u.get());
> }
> };
>
>
>
>
>
> template<typename _Tp>
> struct _MakeUniq
> { typedef unique_ptr<_Tp> __single_object; };
>
> template<typename _Tp>
> struct _MakeUniq<_Tp[]>
> { typedef unique_ptr<_Tp[]> __array; };
>
> template<typename _Tp, size_t _Bound>
> struct _MakeUniq<_Tp[_Bound]>
> { struct __invalid_type { }; };
>
>
> template<typename _Tp, typename... _Args>
> inline typename _MakeUniq<_Tp>::__single_object
> make_unique(_Args&&... __args)
> { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
>
>
> template<typename _Tp>
> inline typename _MakeUniq<_Tp>::__array
> make_unique(size_t __num)
> { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
>
>
> template<typename _Tp, typename... _Args>
> inline typename _MakeUniq<_Tp>::__invalid_type
> make_unique(_Args&&...) = delete;
>
>
>
>
>
>}
># 81 "/usr/include/c++/8/memory" 2 3
># 1 "/usr/include/c++/8/bits/shared_ptr.h" 1 3
># 52 "/usr/include/c++/8/bits/shared_ptr.h" 3
># 1 "/usr/include/c++/8/bits/shared_ptr_base.h" 1 3
># 55 "/usr/include/c++/8/bits/shared_ptr_base.h" 3
># 1 "/usr/include/c++/8/bits/allocated_ptr.h" 1 3
># 40 "/usr/include/c++/8/bits/allocated_ptr.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Alloc>
> struct __allocated_ptr
> {
> using pointer = typename allocator_traits<_Alloc>::pointer;
> using value_type = typename allocator_traits<_Alloc>::value_type;
>
>
> __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
> : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
> { }
>
>
> template<typename _Ptr,
> typename _Req = _Require<is_same<_Ptr, value_type*>>>
> __allocated_ptr(_Alloc& __a, _Ptr __ptr)
> : _M_alloc(std::__addressof(__a)),
> _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
> { }
>
>
> __allocated_ptr(__allocated_ptr&& __gd) noexcept
> : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
> { __gd._M_ptr = nullptr; }
>
>
> ~__allocated_ptr()
> {
> if (_M_ptr != nullptr)
> std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
> }
>
>
> __allocated_ptr&
> operator=(std::nullptr_t) noexcept
> {
> _M_ptr = nullptr;
> return *this;
> }
>
>
> value_type* get() { return std::__to_address(_M_ptr); }
>
> private:
> _Alloc* _M_alloc;
> pointer _M_ptr;
> };
>
>
> template<typename _Alloc>
> __allocated_ptr<_Alloc>
> __allocate_guarded(_Alloc& __a)
> {
> return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
> }
>
>
>}
># 56 "/usr/include/c++/8/bits/shared_ptr_base.h" 2 3
># 1 "/usr/include/c++/8/bits/refwrap.h" 1 3
># 33 "/usr/include/c++/8/bits/refwrap.h" 3
> 
># 34 "/usr/include/c++/8/bits/refwrap.h" 3
># 43 "/usr/include/c++/8/bits/refwrap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Maybe_unary_or_binary_function { };
>
>
> template<typename _Res, typename _T1>
> struct _Maybe_unary_or_binary_function<_Res, _T1>
> : std::unary_function<_T1, _Res> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
> : std::binary_function<_T1, _T2, _Res> { };
>
> template<typename _Signature>
> struct _Mem_fn_traits;
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Mem_fn_traits_base
> {
> using __result_type = _Res;
> using __maybe_type
> = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
> using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
> };
># 97 "/usr/include/c++/8/bits/refwrap.h" 3
>template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
>template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
>template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
>
>
>template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
>template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
>template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
>
>
>
>
>
>
> template<typename _Functor, typename = __void_t<>>
> struct _Maybe_get_result_type
> { };
>
> template<typename _Functor>
> struct _Maybe_get_result_type<_Functor,
> __void_t<typename _Functor::result_type>>
> { typedef typename _Functor::result_type result_type; };
>
>
>
>
>
> template<typename _Functor>
> struct _Weak_result_type_impl
> : _Maybe_get_result_type<_Functor>
> { };
>
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes , bool _NE>
> struct
> _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)>
> { typedef _Res result_type; };
>
>
> template<typename _Functor,
> bool = is_member_function_pointer<_Functor>::value>
> struct _Weak_result_type_memfun
> : _Weak_result_type_impl<_Functor>
> { };
>
>
> template<typename _MemFunPtr>
> struct _Weak_result_type_memfun<_MemFunPtr, true>
> {
> using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
> };
>
>
> template<typename _Func, typename _Class>
> struct _Weak_result_type_memfun<_Func _Class::*, false>
> { };
>
>
>
>
>
> template<typename _Functor>
> struct _Weak_result_type
> : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
> { };
>
>
> template<typename _Tp, typename = __void_t<>>
> struct _Refwrap_base_arg1
> { };
>
>
> template<typename _Tp>
> struct _Refwrap_base_arg1<_Tp,
> __void_t<typename _Tp::argument_type>>
> {
> typedef typename _Tp::argument_type argument_type;
> };
>
>
> template<typename _Tp, typename = __void_t<>>
> struct _Refwrap_base_arg2
> { };
>
>
> template<typename _Tp>
> struct _Refwrap_base_arg2<_Tp,
> __void_t<typename _Tp::first_argument_type,
> typename _Tp::second_argument_type>>
> {
> typedef typename _Tp::first_argument_type first_argument_type;
> typedef typename _Tp::second_argument_type second_argument_type;
> };
>
>
>
>
>
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base
> : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
> { };
>
>
> template<typename _Res, typename _T1 , bool _NE>
> struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) const>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) volatile>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) const volatile>
> : unary_function<_T1, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2 , bool _NE>
> struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) const>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
> : binary_function<_T1, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1 , bool _NE>
> struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)>
> : unary_function<_T1, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2 , bool _NE>
> struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
> struct _Reference_wrapper_base_memfun
> : _Reference_wrapper_base<_Tp>
> { };
>
> template<typename _MemFunPtr>
> struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
> : _Mem_fn_traits<_MemFunPtr>::__maybe_type
> {
> using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
> };
>
>
>
>
>
>
> template<typename _Tp>
> class reference_wrapper
> : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>
> {
> _Tp* _M_data;
>
> public:
> typedef _Tp type;
>
> reference_wrapper(_Tp& __indata) noexcept
> : _M_data(std::__addressof(__indata))
> { }
>
> reference_wrapper(_Tp&&) = delete;
>
> reference_wrapper(const reference_wrapper&) = default;
>
> reference_wrapper&
> operator=(const reference_wrapper&) = default;
>
> operator _Tp&() const noexcept
> { return this->get(); }
>
> _Tp&
> get() const noexcept
> { return *_M_data; }
>
> template<typename... _Args>
> typename result_of<_Tp&(_Args&&...)>::type
> operator()(_Args&&... __args) const
> {
> return std::__invoke(get(), std::forward<_Args>(__args)...);
> }
> };
>
>
>
> template<typename _Tp>
> inline reference_wrapper<_Tp>
> ref(_Tp& __t) noexcept
> { return reference_wrapper<_Tp>(__t); }
>
>
> template<typename _Tp>
> inline reference_wrapper<const _Tp>
> cref(const _Tp& __t) noexcept
> { return reference_wrapper<const _Tp>(__t); }
>
> template<typename _Tp>
> void ref(const _Tp&&) = delete;
>
> template<typename _Tp>
> void cref(const _Tp&&) = delete;
>
>
> template<typename _Tp>
> inline reference_wrapper<_Tp>
> ref(reference_wrapper<_Tp> __t) noexcept
> { return __t; }
>
>
> template<typename _Tp>
> inline reference_wrapper<const _Tp>
> cref(reference_wrapper<_Tp> __t) noexcept
> { return { __t.get() }; }
>
>
>
>
>}
># 57 "/usr/include/c++/8/bits/shared_ptr_base.h" 2 3
>
># 1 "/usr/include/c++/8/ext/aligned_buffer.h" 1 3
># 32 "/usr/include/c++/8/ext/aligned_buffer.h" 3
> 
># 33 "/usr/include/c++/8/ext/aligned_buffer.h" 3
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
> template<typename _Tp>
> struct __aligned_membuf
> {
>
>
>
> struct _Tp2 { _Tp _M_t; };
>
> alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
>
> __aligned_membuf() = default;
>
>
> __aligned_membuf(std::nullptr_t) { }
>
> void*
> _M_addr() noexcept
> { return static_cast<void*>(&_M_storage); }
>
> const void*
> _M_addr() const noexcept
> { return static_cast<const void*>(&_M_storage); }
>
> _Tp*
> _M_ptr() noexcept
> { return static_cast<_Tp*>(_M_addr()); }
>
> const _Tp*
> _M_ptr() const noexcept
> { return static_cast<const _Tp*>(_M_addr()); }
> };
># 87 "/usr/include/c++/8/ext/aligned_buffer.h" 3
> template<typename _Tp>
> struct __aligned_buffer
> : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
> {
> typename
> std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
> _M_storage;
>
> __aligned_buffer() = default;
>
>
> __aligned_buffer(std::nullptr_t) { }
>
> void*
> _M_addr() noexcept
> {
> return static_cast<void*>(&_M_storage);
> }
>
> const void*
> _M_addr() const noexcept
> {
> return static_cast<const void*>(&_M_storage);
> }
>
> _Tp*
> _M_ptr() noexcept
> { return static_cast<_Tp*>(_M_addr()); }
>
> const _Tp*
> _M_ptr() const noexcept
> { return static_cast<const _Tp*>(_M_addr()); }
> };
>
>
>}
># 59 "/usr/include/c++/8/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();
>
> bool
> _M_add_ref_lock_nothrow();
>
> void
> _M_release() noexcept
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
> {
> ;
> _M_dispose();
>
>
>
>
> if (_Mutex_base<_Lp>::_S_need_barriers)
> {
> __atomic_thread_fence (4);
> }
>
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
> -1) == 1)
> {
> ;
> _M_destroy();
> }
> }
> }
>
> void
> _M_weak_add_ref() noexcept
> { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
>
> void
> _M_weak_release() noexcept
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
> {
> ;
> if (_Mutex_base<_Lp>::_S_need_barriers)
> {
>
>
> __atomic_thread_fence (4);
> }
> _M_destroy();
> }
> }
>
> long
> _M_get_use_count() const noexcept
> {
>
>
> return __atomic_load_n(&_M_use_count, 0);
> }
>
> private:
> _Sp_counted_base(_Sp_counted_base const&) = delete;
> _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
>
> _Atomic_word _M_use_count;
> _Atomic_word _M_weak_count;
> };
>
> template<>
> inline void
> _Sp_counted_base<_S_single>::
> _M_add_ref_lock()
> {
> if (_M_use_count == 0)
> __throw_bad_weak_ptr();
> ++_M_use_count;
> }
>
> template<>
> inline void
> _Sp_counted_base<_S_mutex>::
> _M_add_ref_lock()
> {
> __gnu_cxx::__scoped_lock sentry(*this);
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
> {
> _M_use_count = 0;
> __throw_bad_weak_ptr();
> }
> }
>
> template<>
> inline void
> _Sp_counted_base<_S_atomic>::
> _M_add_ref_lock()
> {
>
> _Atomic_word __count = _M_get_use_count();
> do
> {
> if (__count == 0)
> __throw_bad_weak_ptr();
>
>
> }
> while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
> true, 4,
> 0));
> }
>
> template<>
> inline bool
> _Sp_counted_base<_S_single>::
> _M_add_ref_lock_nothrow()
> {
> if (_M_use_count == 0)
> return false;
> ++_M_use_count;
> return true;
> }
>
> template<>
> inline bool
> _Sp_counted_base<_S_mutex>::
> _M_add_ref_lock_nothrow()
> {
> __gnu_cxx::__scoped_lock sentry(*this);
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
> {
> _M_use_count = 0;
> return false;
> }
> return true;
> }
>
> template<>
> inline bool
> _Sp_counted_base<_S_atomic>::
> _M_add_ref_lock_nothrow()
> {
>
> _Atomic_word __count = _M_get_use_count();
> do
> {
> if (__count == 0)
> return false;
>
>
> }
> while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
> true, 4,
> 0));
> return true;
> }
>
> template<>
> inline void
> _Sp_counted_base<_S_single>::_M_add_ref_copy()
> { ++_M_use_count; }
>
> template<>
> inline void
> _Sp_counted_base<_S_single>::_M_release() noexcept
> {
> if (--_M_use_count == 0)
> {
> _M_dispose();
> if (--_M_weak_count == 0)
> _M_destroy();
> }
> }
>
> template<>
> inline void
> _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
> { ++_M_weak_count; }
>
> template<>
> inline void
> _Sp_counted_base<_S_single>::_M_weak_release() noexcept
> {
> if (--_M_weak_count == 0)
> _M_destroy();
> }
>
> template<>
> inline long
> _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
> { return _M_use_count; }
>
>
>
> template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
> class __shared_ptr;
>
> template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
> class __weak_ptr;
>
> template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
> class __enable_shared_from_this;
>
> template<typename _Tp>
> class shared_ptr;
>
> template<typename _Tp>
> class weak_ptr;
>
> template<typename _Tp>
> struct owner_less;
>
> template<typename _Tp>
> class enable_shared_from_this;
>
> template<_Lock_policy _Lp = __default_lock_policy>
> class __weak_count;
>
> template<_Lock_policy _Lp = __default_lock_policy>
> class __shared_count;
>
>
>
> template<typename _Ptr, _Lock_policy _Lp>
> class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
> {
> public:
> explicit
> _Sp_counted_ptr(_Ptr __p) noexcept
> : _M_ptr(__p) { }
>
> virtual void
> _M_dispose() noexcept
> { delete _M_ptr; }
>
> virtual void
> _M_destroy() noexcept
> { delete this; }
>
> virtual void*
> _M_get_deleter(const std::type_info&) noexcept
> { return nullptr; }
>
> _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
> _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
>
> private:
> _Ptr _M_ptr;
> };
>
> template<>
> inline void
> _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
>
> template<>
> inline void
> _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
>
> template<>
> inline void
> _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
>
> template<int _Nm, typename _Tp,
> bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
> struct _Sp_ebo_helper;
>
>
> template<int _Nm, typename _Tp>
> struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
> {
> explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
> explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }
>
> static _Tp&
> _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
> };
>
>
> template<int _Nm, typename _Tp>
> struct _Sp_ebo_helper<_Nm, _Tp, false>
> {
> explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
> explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }
>
> static _Tp&
> _S_get(_Sp_ebo_helper& __eboh)
> { return __eboh._M_tp; }
>
> private:
> _Tp _M_tp;
> };
>
>
> template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
> class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
> {
> class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
> {
> typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
> typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
>
> public:
> _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
> : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
> { }
>
> _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
> _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
>
> _Ptr _M_ptr;
> };
>
> public:
> using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
>
>
> _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
> : _M_impl(__p, std::move(__d), _Alloc()) { }
>
>
> _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
> : _M_impl(__p, std::move(__d), __a) { }
>
> ~_Sp_counted_deleter() noexcept { }
>
> virtual void
> _M_dispose() noexcept
> { _M_impl._M_del()(_M_impl._M_ptr); }
>
> virtual void
> _M_destroy() noexcept
> {
> __allocator_type __a(_M_impl._M_alloc());
> __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
> this->~_Sp_counted_deleter();
> }
>
> virtual void*
> _M_get_deleter(const std::type_info& __ti) noexcept
> {
>
>
>
> return __ti == typeid(_Deleter)
> ? std::__addressof(_M_impl._M_del())
> : nullptr;
>
>
>
> }
>
> private:
> _Impl _M_impl;
> };
>
>
>
> struct _Sp_make_shared_tag
> {
># 523 "/usr/include/c++/8/bits/shared_ptr_base.h" 3
> };
>
> template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
> class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
> {
> class _Impl : _Sp_ebo_helper<0, _Alloc>
> {
> typedef _Sp_ebo_helper<0, _Alloc> _A_base;
>
> public:
> explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
>
> _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
>
> __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
> };
>
> public:
> using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
>
> template<typename... _Args>
> _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
> : _M_impl(__a)
> {
>
>
> allocator_traits<_Alloc>::construct(__a, _M_ptr(),
> std::forward<_Args>(__args)...);
> }
>
> ~_Sp_counted_ptr_inplace() noexcept { }
>
> virtual void
> _M_dispose() noexcept
> {
> allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
> }
>
>
> virtual void
> _M_destroy() noexcept
> {
> __allocator_type __a(_M_impl._M_alloc());
> __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
> this->~_Sp_counted_ptr_inplace();
> }
>
>
> virtual void*
> _M_get_deleter(const std::type_info& __ti) noexcept
> {
>
> if (__ti == typeid(_Sp_make_shared_tag))
>
>
>
> return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
> return nullptr;
> }
>
> private:
> _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
>
> _Impl _M_impl;
> };
>
>
> struct __sp_array_delete
> {
> template<typename _Yp>
> void operator()(_Yp* __p) const { delete[] __p; }
> };
>
> template<_Lock_policy _Lp>
> class __shared_count
> {
> 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>
> __shared_count(_Ptr __p, _Deleter __d)
> : __shared_count(__p, std::move(__d), allocator<void>())
> { }
>
> template<typename _Ptr, typename _Deleter, typename _Alloc>
> __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(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
> _Args&&... __args)
> : _M_pi(0)
> {
> typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
> typename _Sp_cp_type::__allocator_type __a2(__a);
> auto __guard = std::__allocate_guarded(__a2);
> _Sp_cp_type* __mem = __guard.get();
> ::new (__mem) _Sp_cp_type(std::move(__a),
> std::forward<_Args>(__args)...);
> _M_pi = __mem;
> __guard = nullptr;
> }
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
>
> template<typename _Tp>
> explicit
> __shared_count(std::auto_ptr<_Tp>&& __r);
>#pragma GCC diagnostic pop
>
>
>
> template<typename _Tp, typename _Del>
> explicit
> __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
> {
>
>
> if (__r.get() == nullptr)
> return;
>
> using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
> using _Del2 = typename conditional<is_reference<_Del>::value,
> reference_wrapper<typename remove_reference<_Del>::type>,
> _Del>::type;
> using _Sp_cd_type
> = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
> using _Alloc = allocator<_Sp_cd_type>;
> using _Alloc_traits = allocator_traits<_Alloc>;
> _Alloc __a;
> _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
> _Alloc_traits::construct(__a, __mem, __r.release(),
> __r.get_deleter());
> _M_pi = __mem;
> }
>
>
> explicit __shared_count(const __weak_count<_Lp>& __r);
>
>
> explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
>
> ~__shared_count() noexcept
> {
> if (_M_pi != nullptr)
> _M_pi->_M_release();
> }
>
> __shared_count(const __shared_count& __r) noexcept
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != 0)
> _M_pi->_M_add_ref_copy();
> }
>
> __shared_count&
> operator=(const __shared_count& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> if (__tmp != _M_pi)
> {
> if (__tmp != 0)
> __tmp->_M_add_ref_copy();
> if (_M_pi != 0)
> _M_pi->_M_release();
> _M_pi = __tmp;
> }
> return *this;
> }
>
> void
> _M_swap(__shared_count& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> __r._M_pi = _M_pi;
> _M_pi = __tmp;
> }
>
> long
> _M_get_use_count() const noexcept
> { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
>
> bool
> _M_unique() const noexcept
> { return this->_M_get_use_count() == 1; }
>
> void*
> _M_get_deleter(const std::type_info& __ti) const noexcept
> { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
>
> bool
> _M_less(const __shared_count& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
> bool
> _M_less(const __weak_count<_Lp>& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
>
> friend inline bool
> operator==(const __shared_count& __a, const __shared_count& __b) noexcept
> { return __a._M_pi == __b._M_pi; }
>
> private:
> friend class __weak_count<_Lp>;
>
> _Sp_counted_base<_Lp>* _M_pi;
> };
>
>
> template<_Lock_policy _Lp>
> class __weak_count
> {
> public:
> constexpr __weak_count() noexcept : _M_pi(nullptr)
> { }
>
> __weak_count(const __shared_count<_Lp>& __r) noexcept
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != nullptr)
> _M_pi->_M_weak_add_ref();
> }
>
> __weak_count(const __weak_count& __r) noexcept
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != nullptr)
> _M_pi->_M_weak_add_ref();
> }
>
> __weak_count(__weak_count&& __r) noexcept
> : _M_pi(__r._M_pi)
> { __r._M_pi = nullptr; }
>
> ~__weak_count() noexcept
> {
> if (_M_pi != nullptr)
> _M_pi->_M_weak_release();
> }
>
> __weak_count&
> operator=(const __shared_count<_Lp>& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> if (__tmp != nullptr)
> __tmp->_M_weak_add_ref();
> if (_M_pi != nullptr)
> _M_pi->_M_weak_release();
> _M_pi = __tmp;
> return *this;
> }
>
> __weak_count&
> operator=(const __weak_count& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> if (__tmp != nullptr)
> __tmp->_M_weak_add_ref();
> if (_M_pi != nullptr)
> _M_pi->_M_weak_release();
> _M_pi = __tmp;
> return *this;
> }
>
> __weak_count&
> operator=(__weak_count&& __r) noexcept
> {
> if (_M_pi != nullptr)
> _M_pi->_M_weak_release();
> _M_pi = __r._M_pi;
> __r._M_pi = nullptr;
> return *this;
> }
>
> void
> _M_swap(__weak_count& __r) noexcept
> {
> _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
> __r._M_pi = _M_pi;
> _M_pi = __tmp;
> }
>
> long
> _M_get_use_count() const noexcept
> { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }
>
> bool
> _M_less(const __weak_count& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
> bool
> _M_less(const __shared_count<_Lp>& __rhs) const noexcept
> { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
>
>
> friend inline bool
> operator==(const __weak_count& __a, const __weak_count& __b) noexcept
> { return __a._M_pi == __b._M_pi; }
>
> private:
> friend class __shared_count<_Lp>;
>
> _Sp_counted_base<_Lp>* _M_pi;
> };
>
>
> template<_Lock_policy _Lp>
> inline
> __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != nullptr)
> _M_pi->_M_add_ref_lock();
> else
> __throw_bad_weak_ptr();
> }
>
>
> template<_Lock_policy _Lp>
> inline
> __shared_count<_Lp>::
> __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
> : _M_pi(__r._M_pi)
> {
> if (_M_pi != nullptr)
> if (!_M_pi->_M_add_ref_lock_nothrow())
> _M_pi = nullptr;
> }
>
>
>
>
>
>
>
> template<typename _Yp_ptr, typename _Tp_ptr>
> struct __sp_compatible_with
> : false_type
> { };
>
> template<typename _Yp, typename _Tp>
> struct __sp_compatible_with<_Yp*, _Tp*>
> : is_convertible<_Yp*, _Tp*>::type
> { };
>
> template<typename _Up, size_t _Nm>
> struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
> : true_type
> { };
>
> template<typename _Up, size_t _Nm>
> struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
> : true_type
> { };
>
> template<typename _Up, size_t _Nm>
> struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
> : true_type
> { };
>
> template<typename _Up, size_t _Nm>
> struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
> : true_type
> { };
>
>
> template<typename _Up, size_t _Nm, typename _Yp, typename = void>
> struct __sp_is_constructible_arrN
> : false_type
> { };
>
> template<typename _Up, size_t _Nm, typename _Yp>
> struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
> : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
> { };
>
>
> template<typename _Up, typename _Yp, typename = void>
> struct __sp_is_constructible_arr
> : false_type
> { };
>
> template<typename _Up, typename _Yp>
> struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
> : is_convertible<_Yp(*)[], _Up(*)[]>::type
> { };
>
>
> template<typename _Tp, typename _Yp>
> struct __sp_is_constructible;
>
>
> template<typename _Up, size_t _Nm, typename _Yp>
> struct __sp_is_constructible<_Up[_Nm], _Yp>
> : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
> { };
>
>
> template<typename _Up, typename _Yp>
> struct __sp_is_constructible<_Up[], _Yp>
> : __sp_is_constructible_arr<_Up, _Yp>::type
> { };
>
>
> template<typename _Tp, typename _Yp>
> struct __sp_is_constructible
> : is_convertible<_Yp*, _Tp*>::type
> { };
>
>
>
> template<typename _Tp, _Lock_policy _Lp,
> bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
> class __shared_ptr_access
> {
> public:
> using element_type = _Tp;
>
> element_type&
> operator*() const noexcept
> {
> ;
> return *_M_get();
> }
>
> element_type*
> operator->() const noexcept
> {
> ;
> return _M_get();
> }
>
> private:
> element_type*
> _M_get() const noexcept
> { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
> };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> class __shared_ptr_access<_Tp, _Lp, false, true>
> {
> public:
> using element_type = _Tp;
>
> element_type*
> operator->() const noexcept
> {
> auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
> ;
> return __ptr;
> }
> };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> class __shared_ptr_access<_Tp, _Lp, true, false>
> {
> public:
> using element_type = typename remove_extent<_Tp>::type;
># 1047 "/usr/include/c++/8/bits/shared_ptr_base.h" 3
> element_type&
> operator[](ptrdiff_t __i) const
> {
> ;
> ;
> return _M_get()[__i];
> }
>
> private:
> element_type*
> _M_get() const noexcept
> { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
> };
>
> template<typename _Tp, _Lock_policy _Lp>
> class __shared_ptr
> : public __shared_ptr_access<_Tp, _Lp>
> {
> public:
> using element_type = typename remove_extent<_Tp>::type;
>
> private:
>
> template<typename _Yp>
> using _SafeConv
> = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;
>
>
> template<typename _Yp, typename _Res = void>
> using _Compatible = typename
> enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
>
>
> template<typename _Yp>
> using _Assignable = _Compatible<_Yp, __shared_ptr&>;
>
>
> template<typename _Yp, typename _Del, typename _Res = void,
> typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
> using _UniqCompatible = typename enable_if<__and_<
> __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
> >::value, _Res>::type;
>
>
> template<typename _Yp, typename _Del>
> using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;
>
> public:
>
>
> using weak_type = __weak_ptr<_Tp, _Lp>;
>
>
> constexpr __shared_ptr() noexcept
> : _M_ptr(0), _M_refcount()
> { }
>
> template<typename _Yp, typename = _SafeConv<_Yp>>
> explicit
> __shared_ptr(_Yp* __p)
> : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
> {
> static_assert( !is_void<_Yp>::value, "incomplete type" );
> static_assert( sizeof(_Yp) > 0, "incomplete type" );
> _M_enable_shared_from_this_with(__p);
> }
>
> template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
> __shared_ptr(_Yp* __p, _Deleter __d)
> : _M_ptr(__p), _M_refcount(__p, std::move(__d))
> {
> static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
> "deleter expression d(p) is well-formed");
> _M_enable_shared_from_this_with(__p);
> }
>
> template<typename _Yp, typename _Deleter, typename _Alloc,
> typename = _SafeConv<_Yp>>
> __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
> : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
> {
> static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
> "deleter expression d(p) is well-formed");
> _M_enable_shared_from_this_with(__p);
> }
>
> template<typename _Deleter>
> __shared_ptr(nullptr_t __p, _Deleter __d)
> : _M_ptr(0), _M_refcount(__p, std::move(__d))
> { }
>
> template<typename _Deleter, typename _Alloc>
> __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
> : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
> { }
>
> template<typename _Yp>
> __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
> element_type* __p) noexcept
> : _M_ptr(__p), _M_refcount(__r._M_refcount)
> { }
>
> __shared_ptr(const __shared_ptr&) noexcept = default;
> __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
> ~__shared_ptr() = default;
>
> template<typename _Yp, typename = _Compatible<_Yp>>
> __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
> { }
>
> __shared_ptr(__shared_ptr&& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount()
> {
> _M_refcount._M_swap(__r._M_refcount);
> __r._M_ptr = 0;
> }
>
> template<typename _Yp, typename = _Compatible<_Yp>>
> __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount()
> {
> _M_refcount._M_swap(__r._M_refcount);
> __r._M_ptr = 0;
> }
>
> template<typename _Yp, typename = _Compatible<_Yp>>
> explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
> : _M_refcount(__r._M_refcount)
> {
>
>
> _M_ptr = __r._M_ptr;
> }
>
>
> template<typename _Yp, typename _Del,
> typename = _UniqCompatible<_Yp, _Del>>
> __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
> : _M_ptr(__r.get()), _M_refcount()
> {
> auto __raw = __to_address(__r.get());
> _M_refcount = __shared_count<_Lp>(std::move(__r));
> _M_enable_shared_from_this_with(__raw);
> }
># 1212 "/usr/include/c++/8/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)
> {
>
> ;
> __shared_ptr(__p).swap(*this);
> }
>
> template<typename _Yp, typename _Deleter>
> _SafeConv<_Yp>
> reset(_Yp* __p, _Deleter __d)
> { __shared_ptr(__p, std::move(__d)).swap(*this); }
>
> template<typename _Yp, typename _Deleter, typename _Alloc>
> _SafeConv<_Yp>
> reset(_Yp* __p, _Deleter __d, _Alloc __a)
> { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }
>
> element_type*
> get() const noexcept
> { return _M_ptr; }
>
> explicit operator bool() const
> { return _M_ptr == 0 ? false : true; }
>
> bool
> unique() const noexcept
> { return _M_refcount._M_unique(); }
>
> long
> use_count() const noexcept
> { return _M_refcount._M_get_use_count(); }
>
> void
> swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
> {
> std::swap(_M_ptr, __other._M_ptr);
> _M_refcount._M_swap(__other._M_refcount);
> }
>
> 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_make_shared_tag __tag, const _Alloc& __a,
> _Args&&... __args)
> : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
> std::forward<_Args>(__args)...)
> {
>
>
>
> void* __p = _M_refcount._M_get_deleter(typeid(__tag));
>
>
>
> _M_ptr = static_cast<_Tp*>(__p);
> _M_enable_shared_from_this_with(_M_ptr);
> }
>
> template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
> typename... _Args>
> friend __shared_ptr<_Tp1, _Lp1>
> __allocate_shared(const _Alloc& __a, _Args&&... __args);
>
>
>
> __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
> : _M_refcount(__r._M_refcount, std::nothrow)
> {
> _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
> }
>
> friend class __weak_ptr<_Tp, _Lp>;
>
> private:
>
> template<typename _Yp>
> using __esft_base_t = decltype(__enable_shared_from_this_base(
> std::declval<const __shared_count<_Lp>&>(),
> std::declval<_Yp*>()));
>
>
> template<typename _Yp, typename = void>
> struct __has_esft_base
> : false_type { };
>
> template<typename _Yp>
> struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
> : __not_<is_array<_Tp>> { };
>
> template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
> typename enable_if<__has_esft_base<_Yp2>::value>::type
> _M_enable_shared_from_this_with(_Yp* __p) noexcept
> {
> if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
> __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
> }
>
> template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
> typename enable_if<!__has_esft_base<_Yp2>::value>::type
> _M_enable_shared_from_this_with(_Yp*) noexcept
> { }
>
> void*
> _M_get_deleter(const std::type_info& __ti) const noexcept
> { return _M_refcount._M_get_deleter(__ti); }
>
> template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
> template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
>
> template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
> friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
>
> template<typename _Del, typename _Tp1>
> friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;
>
> element_type* _M_ptr;
> __shared_count<_Lp> _M_refcount;
> };
>
>
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator==(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return __a.get() == __b.get(); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return !__a; }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return !__a; }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return __a.get() != __b.get(); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return (bool)__a; }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return (bool)__a; }
>
> template<typename _Tp, typename _Up, _Lock_policy _Lp>
> inline bool
> operator<(const __shared_ptr<_Tp, _Lp>& __a,
> const __shared_ptr<_Up, _Lp>& __b) noexcept
> {
> using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
> using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
> using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
> return less<_Vp>()(__a.get(), __b.get());
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> {
> using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
> return less<_Tp_elt*>()(__a.get(), nullptr);
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> {
> using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
> return less<_Tp_elt*>()(nullptr, __a.get());
> }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return !(__b < __a); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator>(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return (__b < __a); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return nullptr < __a; }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return __a < nullptr; }
>
> template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
> inline bool
> operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
> const __shared_ptr<_Tp2, _Lp>& __b) noexcept
> { return !(__a < __b); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Sp>
> struct _Sp_less : public binary_function<_Sp, _Sp, bool>
> {
> bool
> operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
> {
> typedef typename _Sp::element_type element_type;
> return std::less<element_type*>()(__lhs.get(), __rhs.get());
> }
> };
>
> template<typename _Tp, _Lock_policy _Lp>
> struct less<__shared_ptr<_Tp, _Lp>>
> : public _Sp_less<__shared_ptr<_Tp, _Lp>>
> { };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> inline void
> swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
> { __a.swap(__b); }
># 1540 "/usr/include/c++/8/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;
># 1622 "/usr/include/c++/8/bits/shared_ptr_base.h" 3
> template<typename _Yp, typename = _Compatible<_Yp>>
> __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
> : _M_refcount(__r._M_refcount)
> { _M_ptr = __r.lock().get(); }
>
> template<typename _Yp, typename = _Compatible<_Yp>>
> __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
> { }
>
> __weak_ptr(__weak_ptr&& __r) noexcept
> : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
> { __r._M_ptr = nullptr; }
>
> template<typename _Yp, typename = _Compatible<_Yp>>
> __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
> : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
> { __r._M_ptr = nullptr; }
>
> __weak_ptr&
> operator=(const __weak_ptr& __r) noexcept = default;
>
> template<typename _Yp>
> _Assignable<_Yp>
> operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
> {
> _M_ptr = __r.lock().get();
> _M_refcount = __r._M_refcount;
> return *this;
> }
>
> template<typename _Yp>
> _Assignable<_Yp>
> operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
> {
> _M_ptr = __r._M_ptr;
> _M_refcount = __r._M_refcount;
> return *this;
> }
>
> __weak_ptr&
> operator=(__weak_ptr&& __r) noexcept
> {
> _M_ptr = __r._M_ptr;
> _M_refcount = std::move(__r._M_refcount);
> __r._M_ptr = nullptr;
> return *this;
> }
>
> template<typename _Yp>
> _Assignable<_Yp>
> operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
> {
> _M_ptr = __r.lock().get();
> _M_refcount = std::move(__r._M_refcount);
> __r._M_ptr = nullptr;
> return *this;
> }
>
> __shared_ptr<_Tp, _Lp>
> lock() const noexcept
> { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
>
> long
> use_count() const noexcept
> { return _M_refcount._M_get_use_count(); }
>
> bool
> expired() const noexcept
> { return _M_refcount._M_get_use_count() == 0; }
>
> template<typename _Tp1>
> bool
> owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
> { return _M_refcount._M_less(__rhs._M_refcount); }
>
> template<typename _Tp1>
> bool
> owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
> { return _M_refcount._M_less(__rhs._M_refcount); }
>
> void
> reset() noexcept
> { __weak_ptr().swap(*this); }
>
> void
> swap(__weak_ptr& __s) noexcept
> {
> std::swap(_M_ptr, __s._M_ptr);
> _M_refcount._M_swap(__s._M_refcount);
> }
>
> private:
>
> void
> _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
> {
> if (use_count() == 0)
> {
> _M_ptr = __ptr;
> _M_refcount = __refcount;
> }
> }
>
> template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
> template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
> friend class __enable_shared_from_this<_Tp, _Lp>;
> friend class enable_shared_from_this<_Tp>;
>
> element_type* _M_ptr;
> __weak_count<_Lp> _M_refcount;
> };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> inline void
> swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
> { __a.swap(__b); }
>
> template<typename _Tp, typename _Tp1>
> struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
> { return __lhs.owner_before(__rhs); }
>
> bool
> operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
> { return __lhs.owner_before(__rhs); }
>
> bool
> operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
> { return __lhs.owner_before(__rhs); }
> };
>
> template<>
> struct _Sp_owner_less<void, void>
> {
> template<typename _Tp, typename _Up>
> auto
> operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
> -> decltype(__lhs.owner_before(__rhs))
> { return __lhs.owner_before(__rhs); }
>
> using is_transparent = void;
> };
>
> template<typename _Tp, _Lock_policy _Lp>
> struct owner_less<__shared_ptr<_Tp, _Lp>>
> : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
> { };
>
> template<typename _Tp, _Lock_policy _Lp>
> struct owner_less<__weak_ptr<_Tp, _Lp>>
> : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
> { };
>
>
> template<typename _Tp, _Lock_policy _Lp>
> class __enable_shared_from_this
> {
> protected:
> constexpr __enable_shared_from_this() noexcept { }
>
> __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
>
> __enable_shared_from_this&
> operator=(const __enable_shared_from_this&) noexcept
> { return *this; }
>
> ~__enable_shared_from_this() { }
>
> public:
> __shared_ptr<_Tp, _Lp>
> shared_from_this()
> { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
>
> __shared_ptr<const _Tp, _Lp>
> shared_from_this() const
> { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
>
>
> __weak_ptr<_Tp, _Lp>
> weak_from_this() noexcept
> { return this->_M_weak_this; }
>
> __weak_ptr<const _Tp, _Lp>
> weak_from_this() const noexcept
> { return this->_M_weak_this; }
>
>
> private:
> template<typename _Tp1>
> void
> _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
> { _M_weak_this._M_assign(__p, __n); }
>
> friend const __enable_shared_from_this*
> __enable_shared_from_this_base(const __shared_count<_Lp>&,
> const __enable_shared_from_this* __p)
> { return __p; }
>
> template<typename, _Lock_policy>
> friend class __shared_ptr;
>
> mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
> };
>
> template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
> inline __shared_ptr<_Tp, _Lp>
> __allocate_shared(const _Alloc& __a, _Args&&... __args)
> {
> return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
> std::forward<_Args>(__args)...);
> }
>
> template<typename _Tp, _Lock_policy _Lp, typename... _Args>
> inline __shared_ptr<_Tp, _Lp>
> __make_shared(_Args&&... __args)
> {
> typedef typename std::remove_const<_Tp>::type _Tp_nc;
> return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Tp, _Lock_policy _Lp>
> struct hash<__shared_ptr<_Tp, _Lp>>
> : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
> {
> size_t
> operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
> {
> return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
> __s.get());
> }
> };
>
>
>}
># 53 "/usr/include/c++/8/bits/shared_ptr.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> 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>
> 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) { }
># 154 "/usr/include/c++/8/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)) { }
># 172 "/usr/include/c++/8/bits/shared_ptr.h" 3
> template<typename _Deleter>
> shared_ptr(nullptr_t __p, _Deleter __d)
> : __shared_ptr<_Tp>(__p, std::move(__d)) { }
># 191 "/usr/include/c++/8/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)) { }
># 211 "/usr/include/c++/8/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)) { }
># 233 "/usr/include/c++/8/bits/shared_ptr.h" 3
> template<typename _Yp>
> shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
> : __shared_ptr<_Tp>(__r, __p) { }
># 244 "/usr/include/c++/8/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)) { }
># 274 "/usr/include/c++/8/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)) { }
># 307 "/usr/include/c++/8/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_make_shared_tag __tag, const _Alloc& __a,
> _Args&&... __args)
> : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
> { }
>
> template<typename _Yp, typename _Alloc, typename... _Args>
> friend shared_ptr<_Yp>
> allocate_shared(const _Alloc& __a, _Args&&... __args);
>
>
> shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
> : __shared_ptr<_Tp>(__r, std::nothrow) { }
>
> friend class weak_ptr<_Tp>;
> };
>
>
> template<typename _Tp>
> shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
> template<typename _Tp, typename _Del>
> shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>;
>
>
>
> template<typename _Tp, typename _Up>
> inline bool
> operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
> { return __a.get() == __b.get(); }
>
> template<typename _Tp>
> inline bool
> operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return !__a; }
>
> template<typename _Tp>
> inline bool
> operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return !__a; }
>
> template<typename _Tp, typename _Up>
> inline bool
> operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
> { return __a.get() != __b.get(); }
>
> template<typename _Tp>
> inline bool
> operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return (bool)__a; }
>
> template<typename _Tp>
> inline bool
> operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return (bool)__a; }
>
> template<typename _Tp, typename _Up>
> inline bool
> operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
> {
> using _Tp_elt = typename shared_ptr<_Tp>::element_type;
> using _Up_elt = typename shared_ptr<_Up>::element_type;
> using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
> return less<_Vp>()(__a.get(), __b.get());
> }
>
> template<typename _Tp>
> inline bool
> operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> {
> using _Tp_elt = typename shared_ptr<_Tp>::element_type;
> return less<_Tp_elt*>()(__a.get(), nullptr);
> }
>
> template<typename _Tp>
> inline bool
> operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> {
> using _Tp_elt = typename shared_ptr<_Tp>::element_type;
> return less<_Tp_elt*>()(nullptr, __a.get());
> }
>
> template<typename _Tp, typename _Up>
> inline bool
> operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
> { return !(__b < __a); }
>
> template<typename _Tp>
> inline bool
> operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Tp>
> inline bool
> operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp, typename _Up>
> inline bool
> operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
> { return (__b < __a); }
>
> template<typename _Tp>
> inline bool
> operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return nullptr < __a; }
>
> template<typename _Tp>
> inline bool
> operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return __a < nullptr; }
>
> template<typename _Tp, typename _Up>
> inline bool
> operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
> { return !(__a < __b); }
>
> template<typename _Tp>
> inline bool
> operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
> { return !(__a < nullptr); }
>
> template<typename _Tp>
> inline bool
> operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
> { return !(nullptr < __a); }
>
> template<typename _Tp>
> struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
> { };
>
>
> 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>
> 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;
> };
># 702 "/usr/include/c++/8/bits/shared_ptr.h" 3
> template<typename _Tp, typename _Alloc, typename... _Args>
> inline shared_ptr<_Tp>
> allocate_shared(const _Alloc& __a, _Args&&... __args)
> {
> return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
> std::forward<_Args>(__args)...);
> }
># 717 "/usr/include/c++/8/bits/shared_ptr.h" 3
> template<typename _Tp, typename... _Args>
> inline shared_ptr<_Tp>
> make_shared(_Args&&... __args)
> {
> typedef typename std::remove_const<_Tp>::type _Tp_nc;
> return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Tp>
> struct hash<shared_ptr<_Tp>>
> : public __hash_base<size_t, shared_ptr<_Tp>>
> {
> size_t
> operator()(const shared_ptr<_Tp>& __s) const noexcept
> {
> return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
> }
> };
>
>
>
>
>}
># 82 "/usr/include/c++/8/memory" 2 3
># 1 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 1 3
># 33 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 3
># 1 "/usr/include/c++/8/bits/atomic_base.h" 1 3
># 33 "/usr/include/c++/8/bits/atomic_base.h" 3
> 
># 34 "/usr/include/c++/8/bits/atomic_base.h" 3
>
>
>
># 1 "/usr/include/c++/8/bits/atomic_lockfree_defines.h" 1 3
># 33 "/usr/include/c++/8/bits/atomic_lockfree_defines.h" 3
> 
># 34 "/usr/include/c++/8/bits/atomic_lockfree_defines.h" 3
># 38 "/usr/include/c++/8/bits/atomic_base.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/8/bits/atomic_base.h" 3
> typedef enum memory_order
> {
> memory_order_relaxed,
> memory_order_consume,
> memory_order_acquire,
> memory_order_release,
> memory_order_acq_rel,
> memory_order_seq_cst
> } memory_order;
>
> enum __memory_order_modifier
> {
> __memory_order_mask = 0x0ffff,
> __memory_order_modifier_mask = 0xffff0000,
> __memory_order_hle_acquire = 0x10000,
> __memory_order_hle_release = 0x20000
> };
>
> constexpr memory_order
> operator|(memory_order __m, __memory_order_modifier __mod)
> {
> return memory_order(__m | int(__mod));
> }
>
> constexpr memory_order
> operator&(memory_order __m, __memory_order_modifier __mod)
> {
> return memory_order(__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)
> | (__m & __memory_order_modifier_mask));
> }
>
> inline __attribute__((__always_inline__)) void
> atomic_thread_fence(memory_order __m) noexcept
> { __atomic_thread_fence(__m); }
>
> inline __attribute__((__always_inline__)) void
> atomic_signal_fence(memory_order __m) noexcept
> { __atomic_signal_fence(__m); }
>
>
> template<typename _Tp>
> inline _Tp
> kill_dependency(_Tp __y) noexcept
> {
> _Tp __ret(__y);
> return __ret;
> }
>
>
>
> template<typename _IntTp>
> struct __atomic_base;
>
>
>
>
> template<typename _Tp>
> struct atomic;
>
> template<typename _Tp>
> struct atomic<_Tp*>;
>
>
>
> typedef bool __atomic_flag_data_type;
># 148 "/usr/include/c++/8/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, __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, __m);
> }
>
> inline __attribute__((__always_inline__)) void
> clear(memory_order __m = memory_order_seq_cst) noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_clear (&_M_i, __m);
> }
>
> inline __attribute__((__always_inline__)) void
> clear(memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_clear (&_M_i, __m);
> }
>
> private:
> static constexpr __atomic_flag_data_type
> _S_init(bool __i)
> { return __i ? 1 : 0; }
> };
># 237 "/usr/include/c++/8/bits/atomic_base.h" 3
> template<typename _ITp>
> struct __atomic_base
> {
> private:
> typedef _ITp __int_type;
>
> static constexpr int _S_alignment =
> sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);
>
> alignas(_S_alignment) __int_type _M_i;
>
> public:
> __atomic_base() noexcept = default;
> ~__atomic_base() noexcept = default;
> __atomic_base(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) volatile = delete;
>
>
> constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
>
> operator __int_type() const noexcept
> { return load(); }
>
> operator __int_type() const volatile noexcept
> { return load(); }
>
> __int_type
> operator=(__int_type __i) noexcept
> {
> store(__i);
> return __i;
> }
>
> __int_type
> operator=(__int_type __i) volatile noexcept
> {
> store(__i);
> return __i;
> }
>
> __int_type
> operator++(int) noexcept
> { return fetch_add(1); }
>
> __int_type
> operator++(int) volatile noexcept
> { return fetch_add(1); }
>
> __int_type
> operator--(int) noexcept
> { return fetch_sub(1); }
>
> __int_type
> operator--(int) volatile noexcept
> { return fetch_sub(1); }
>
> __int_type
> operator++() noexcept
> { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator++() volatile noexcept
> { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator--() noexcept
> { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator--() volatile noexcept
> { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
>
> __int_type
> operator+=(__int_type __i) noexcept
> { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator+=(__int_type __i) volatile noexcept
> { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator-=(__int_type __i) noexcept
> { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator-=(__int_type __i) volatile noexcept
> { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator&=(__int_type __i) noexcept
> { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator&=(__int_type __i) volatile noexcept
> { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator|=(__int_type __i) noexcept
> { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator|=(__int_type __i) volatile noexcept
> { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator^=(__int_type __i) noexcept
> { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> __int_type
> operator^=(__int_type __i) volatile noexcept
> { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
>
> bool
> is_lock_free() const noexcept
> {
>
> return __atomic_is_lock_free(sizeof(_M_i),
> reinterpret_cast<void *>(-__alignof(_M_i)));
> }
>
> bool
> is_lock_free() const volatile noexcept
> {
>
> return __atomic_is_lock_free(sizeof(_M_i),
> reinterpret_cast<void *>(-__alignof(_M_i)));
> }
>
> inline __attribute__((__always_inline__)) void
> store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_store_n(&_M_i, __i, __m);
> }
>
> inline __attribute__((__always_inline__)) void
> store(__int_type __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_store_n(&_M_i, __i, __m);
> }
>
> inline __attribute__((__always_inline__)) __int_type
> load(memory_order __m = memory_order_seq_cst) const noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_i, __m);
> }
>
> inline __attribute__((__always_inline__)) __int_type
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_i, __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, __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, __m);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m1, memory_order __m2) noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return compare_exchange_weak(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_weak(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return compare_exchange_weak(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m1, memory_order __m2) noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
>
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return compare_exchange_strong(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_strong(__int_type& __i1, __int_type __i2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return compare_exchange_strong(__i1, __i2, __m,
> __cmpexch_failure_order(__m));
> }
>
> inline __attribute__((__always_inline__)) __int_type
> fetch_add(__int_type __i,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_add(&_M_i, __i, __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, __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, __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, __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, __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, __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, __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, __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, __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, __m); }
> };
>
>
>
> template<typename _PTp>
> struct __atomic_base<_PTp*>
> {
> private:
> typedef _PTp* __pointer_type;
>
> __pointer_type _M_p;
>
>
> constexpr ptrdiff_t
> _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
>
> constexpr ptrdiff_t
> _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
>
> public:
> __atomic_base() noexcept = default;
> ~__atomic_base() noexcept = default;
> __atomic_base(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) = delete;
> __atomic_base& operator=(const __atomic_base&) volatile = delete;
>
>
> constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
>
> operator __pointer_type() const noexcept
> { return load(); }
>
> operator __pointer_type() const volatile noexcept
> { return load(); }
>
> __pointer_type
> operator=(__pointer_type __p) noexcept
> {
> store(__p);
> return __p;
> }
>
> __pointer_type
> operator=(__pointer_type __p) volatile noexcept
> {
> store(__p);
> return __p;
> }
>
> __pointer_type
> operator++(int) noexcept
> { return fetch_add(1); }
>
> __pointer_type
> operator++(int) volatile noexcept
> { return fetch_add(1); }
>
> __pointer_type
> operator--(int) noexcept
> { return fetch_sub(1); }
>
> __pointer_type
> operator--(int) volatile noexcept
> { return fetch_sub(1); }
>
> __pointer_type
> operator++() noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator++() volatile noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator--() noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator--() volatile noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
> memory_order_seq_cst); }
>
> __pointer_type
> operator+=(ptrdiff_t __d) noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> __pointer_type
> operator+=(ptrdiff_t __d) volatile noexcept
> { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) volatile noexcept
> { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
> memory_order_seq_cst); }
>
> bool
> is_lock_free() const noexcept
> {
>
> return __atomic_is_lock_free(sizeof(_M_p),
> reinterpret_cast<void *>(-__alignof(_M_p)));
> }
>
> bool
> is_lock_free() const volatile noexcept
> {
>
> return __atomic_is_lock_free(sizeof(_M_p),
> reinterpret_cast<void *>(-__alignof(_M_p)));
> }
>
> inline __attribute__((__always_inline__)) void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> memory_order __b = __m & __memory_order_mask;
>
> ;
> ;
> ;
>
> __atomic_store_n(&_M_p, __p, __m);
> }
>
> inline __attribute__((__always_inline__)) void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
> ;
>
> __atomic_store_n(&_M_p, __p, __m);
> }
>
> inline __attribute__((__always_inline__)) __pointer_type
> load(memory_order __m = memory_order_seq_cst) const noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_p, __m);
> }
>
> inline __attribute__((__always_inline__)) __pointer_type
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> {
> memory_order __b = __m & __memory_order_mask;
> ;
> ;
>
> return __atomic_load_n(&_M_p, __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, __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, __m);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
> }
>
> inline __attribute__((__always_inline__)) bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> {
> memory_order __b2 = __m2 & __memory_order_mask;
> memory_order __b1 = __m1 & __memory_order_mask;
>
> ;
> ;
> ;
>
> return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
> }
>
> inline __attribute__((__always_inline__)) __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
>
> inline __attribute__((__always_inline__)) __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
>
> inline __attribute__((__always_inline__)) __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
>
> inline __attribute__((__always_inline__)) __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
> };
>
>
>
>
>}
># 34 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> 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;
>
>
>
> };
>
>
>
>
>
>
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
> {
>
> return __gthread_active_p() == 0;
>
>
>
> }
>
> template<typename _Tp>
> inline bool
> atomic_is_lock_free(const shared_ptr<_Tp>* __p)
> { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
># 96 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 3
> template<typename _Tp>
> inline shared_ptr<_Tp>
> atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
> {
> _Sp_locker __lock{__p};
> return *__p;
> }
>
> template<typename _Tp>
> inline shared_ptr<_Tp>
> atomic_load(const shared_ptr<_Tp>* __p)
> { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
> {
> _Sp_locker __lock{__p};
> return *__p;
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
> { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
># 132 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 3
> template<typename _Tp>
> inline void
> atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
> memory_order)
> {
> _Sp_locker __lock{__p};
> __p->swap(__r);
> }
>
> template<typename _Tp>
> inline void
> atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
> { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline void
> atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
> __shared_ptr<_Tp, _Lp> __r,
> memory_order)
> {
> _Sp_locker __lock{__p};
> __p->swap(__r);
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline void
> atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
> { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
># 169 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 3
> template<typename _Tp>
> inline shared_ptr<_Tp>
> atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
> memory_order)
> {
> _Sp_locker __lock{__p};
> __p->swap(__r);
> return __r;
> }
>
> template<typename _Tp>
> inline shared_ptr<_Tp>
> atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
> {
> return std::atomic_exchange_explicit(__p, std::move(__r),
> memory_order_seq_cst);
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
> __shared_ptr<_Tp, _Lp> __r,
> memory_order)
> {
> _Sp_locker __lock{__p};
> __p->swap(__r);
> return __r;
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline __shared_ptr<_Tp, _Lp>
> atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
> {
> return std::atomic_exchange_explicit(__p, std::move(__r),
> memory_order_seq_cst);
> }
># 218 "/usr/include/c++/8/bits/shared_ptr_atomic.h" 3
> template<typename _Tp>
> bool
> atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
> shared_ptr<_Tp>* __v,
> shared_ptr<_Tp> __w,
> memory_order,
> memory_order)
> {
> shared_ptr<_Tp> __x;
> _Sp_locker __lock{__p, __v};
> owner_less<shared_ptr<_Tp>> __less;
> if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
> {
> __x = std::move(*__p);
> *__p = std::move(__w);
> return true;
> }
> __x = std::move(*__v);
> *__v = *__p;
> return false;
> }
>
> template<typename _Tp>
> inline bool
> atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
> shared_ptr<_Tp> __w)
> {
> return std::atomic_compare_exchange_strong_explicit(__p, __v,
> std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
> }
>
> template<typename _Tp>
> inline bool
> atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
> shared_ptr<_Tp>* __v,
> shared_ptr<_Tp> __w,
> memory_order __success,
> memory_order __failure)
> {
> return std::atomic_compare_exchange_strong_explicit(__p, __v,
> std::move(__w), __success, __failure);
> }
>
> template<typename _Tp>
> inline bool
> atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
> shared_ptr<_Tp> __w)
> {
> return std::atomic_compare_exchange_weak_explicit(__p, __v,
> std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> bool
> atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
> __shared_ptr<_Tp, _Lp>* __v,
> __shared_ptr<_Tp, _Lp> __w,
> memory_order,
> memory_order)
> {
> __shared_ptr<_Tp, _Lp> __x;
> _Sp_locker __lock{__p, __v};
> owner_less<__shared_ptr<_Tp, _Lp>> __less;
> if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
> {
> __x = std::move(*__p);
> *__p = std::move(__w);
> return true;
> }
> __x = std::move(*__v);
> *__v = *__p;
> return false;
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
> __shared_ptr<_Tp, _Lp>* __v,
> __shared_ptr<_Tp, _Lp> __w)
> {
> return std::atomic_compare_exchange_strong_explicit(__p, __v,
> std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
> __shared_ptr<_Tp, _Lp>* __v,
> __shared_ptr<_Tp, _Lp> __w,
> memory_order __success,
> memory_order __failure)
> {
> return std::atomic_compare_exchange_strong_explicit(__p, __v,
> std::move(__w), __success, __failure);
> }
>
> template<typename _Tp, _Lock_policy _Lp>
> inline bool
> atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
> __shared_ptr<_Tp, _Lp>* __v,
> __shared_ptr<_Tp, _Lp> __w)
> {
> return std::atomic_compare_exchange_weak_explicit(__p, __v,
> std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
> }
>
>
>
>
>
>}
># 83 "/usr/include/c++/8/memory" 2 3
>
># 1 "/usr/include/c++/8/backward/auto_ptr.h" 1 3
># 36 "/usr/include/c++/8/backward/auto_ptr.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 47 "/usr/include/c++/8/backward/auto_ptr.h" 3
> template<typename _Tp1>
> struct auto_ptr_ref
> {
> _Tp1* _M_ptr;
>
> explicit
> auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
> } __attribute__ ((__deprecated__));
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
># 88 "/usr/include/c++/8/backward/auto_ptr.h" 3
> template<typename _Tp>
> class auto_ptr
> {
> private:
> _Tp* _M_ptr;
>
> public:
>
> typedef _Tp element_type;
>
>
>
>
>
>
>
> explicit
> auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
># 114 "/usr/include/c++/8/backward/auto_ptr.h" 3
> auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
># 126 "/usr/include/c++/8/backward/auto_ptr.h" 3
> template<typename _Tp1>
> auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
># 137 "/usr/include/c++/8/backward/auto_ptr.h" 3
> auto_ptr&
> operator=(auto_ptr& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 154 "/usr/include/c++/8/backward/auto_ptr.h" 3
> template<typename _Tp1>
> auto_ptr&
> operator=(auto_ptr<_Tp1>& __a) throw()
> {
> reset(__a.release());
> return *this;
> }
># 172 "/usr/include/c++/8/backward/auto_ptr.h" 3
> ~auto_ptr() { delete _M_ptr; }
># 182 "/usr/include/c++/8/backward/auto_ptr.h" 3
> element_type&
> operator*() const throw()
> {
> ;
> return *_M_ptr;
> }
>
>
>
>
>
>
>
> element_type*
> operator->() const throw()
> {
> ;
> return _M_ptr;
> }
># 212 "/usr/include/c++/8/backward/auto_ptr.h" 3
> element_type*
> get() const throw() { return _M_ptr; }
># 226 "/usr/include/c++/8/backward/auto_ptr.h" 3
> element_type*
> release() throw()
> {
> element_type* __tmp = _M_ptr;
> _M_ptr = 0;
> return __tmp;
> }
># 241 "/usr/include/c++/8/backward/auto_ptr.h" 3
> void
> reset(element_type* __p = 0) throw()
> {
> if (__p != _M_ptr)
> {
> delete _M_ptr;
> _M_ptr = __p;
> }
> }
># 266 "/usr/include/c++/8/backward/auto_ptr.h" 3
> auto_ptr(auto_ptr_ref<element_type> __ref) throw()
> : _M_ptr(__ref._M_ptr) { }
>
> auto_ptr&
> operator=(auto_ptr_ref<element_type> __ref) throw()
> {
> if (__ref._M_ptr != this->get())
> {
> delete _M_ptr;
> _M_ptr = __ref._M_ptr;
> }
> return *this;
> }
>
> template<typename _Tp1>
> operator auto_ptr_ref<_Tp1>() throw()
> { return auto_ptr_ref<_Tp1>(this->release()); }
>
> template<typename _Tp1>
> operator auto_ptr<_Tp1>() throw()
> { return auto_ptr<_Tp1>(this->release()); }
> } __attribute__ ((__deprecated__));
>
>
>
> template<>
> class auto_ptr<void>
> {
> public:
> typedef void element_type;
> } __attribute__ ((__deprecated__));
>
>
> template<_Lock_policy _Lp>
> template<typename _Tp>
> inline
> __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
> : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
> { __r.release(); }
>
> template<typename _Tp, _Lock_policy _Lp>
> template<typename _Tp1, typename>
> inline
> __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
> : _M_ptr(__r.get()), _M_refcount()
> {
> 
> static_assert( sizeof(_Tp1) > 0, "incomplete type" );
> _Tp1* __tmp = __r.get();
> _M_refcount = __shared_count<_Lp>(std::move(__r));
> _M_enable_shared_from_this_with(__tmp);
> }
>
> template<typename _Tp>
> template<typename _Tp1, typename>
> inline
> shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
> : __shared_ptr<_Tp>(std::move(__r)) { }
>
> template<typename _Tp, typename _Dp>
> template<typename _Up, typename>
> inline
> unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
> : _M_t(__u.release(), deleter_type()) { }
>
>
>#pragma GCC diagnostic pop
>
>
>}
># 85 "/usr/include/c++/8/memory" 2 3
># 93 "/usr/include/c++/8/memory" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 113 "/usr/include/c++/8/memory" 3
>inline void*
>align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
>{
> const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);
> const auto __aligned = (__intptr - 1u + __align) & -__align;
> const auto __diff = __aligned - __intptr;
> if ((__size + __diff) > __space)
> return nullptr;
> else
> {
> __space -= __diff;
> return __ptr = reinterpret_cast<void*>(__aligned);
> }
>}
>
>
>
>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; }
>
>
>}
># 37 "/usr/local/include/fmt/format.h" 2 3
># 54 "/usr/local/include/fmt/format.h" 3
># 1 "/usr/local/include/fmt/core.h" 1 3
># 11 "/usr/local/include/fmt/core.h" 3
># 1 "/usr/include/c++/8/cassert" 1 3
># 41 "/usr/include/c++/8/cassert" 3
> 
># 42 "/usr/include/c++/8/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)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 44 "/usr/include/c++/8/cassert" 2 3
># 12 "/usr/local/include/fmt/core.h" 2 3
># 1 "/usr/include/c++/8/cstdio" 1 3
># 39 "/usr/include/c++/8/cstdio" 3
> 
># 40 "/usr/include/c++/8/cstdio" 3
># 13 "/usr/local/include/fmt/core.h" 2 3
># 1 "/usr/include/c++/8/cstring" 1 3
># 39 "/usr/include/c++/8/cstring" 3
> 
># 40 "/usr/include/c++/8/cstring" 3
># 14 "/usr/local/include/fmt/core.h" 2 3
># 1 "/usr/include/c++/8/iterator" 1 3
># 58 "/usr/include/c++/8/iterator" 3
> 
># 59 "/usr/include/c++/8/iterator" 3
>
>
>
>
>
>
>
># 1 "/usr/include/c++/8/bits/stream_iterator.h" 1 3
># 33 "/usr/include/c++/8/bits/stream_iterator.h" 3
> 
># 34 "/usr/include/c++/8/bits/stream_iterator.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
> class istream_iterator
> : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
> {
> public:
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
> private:
> istream_type* _M_stream;
> _Tp _M_value;
> bool _M_ok;
>
> public:
>
> constexpr istream_iterator()
> : _M_stream(0), _M_value(), _M_ok(false) {}
>
>
> istream_iterator(istream_type& __s)
> : _M_stream(std::__addressof(__s))
> { _M_read(); }
>
> istream_iterator(const istream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
> _M_ok(__obj._M_ok)
> { }
>
> const _Tp&
> operator*() const
> {
>
>
> ;
> return _M_value;
> }
>
> const _Tp*
> operator->() const { return std::__addressof((operator*())); }
>
> istream_iterator&
> operator++()
> {
>
>
> ;
> _M_read();
> return *this;
> }
>
> istream_iterator
> operator++(int)
> {
>
>
> ;
> istream_iterator __tmp = *this;
> _M_read();
> return __tmp;
> }
>
> bool
> _M_equal(const istream_iterator& __x) const
> { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
>
> private:
> void
> _M_read()
> {
> _M_ok = (_M_stream && *_M_stream) ? true : false;
> if (_M_ok)
> {
> *_M_stream >> _M_value;
> _M_ok = *_M_stream ? true : false;
> }
> }
> };
>
>
> template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
> inline bool
> operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return __x._M_equal(__y); }
>
>
> template <class _Tp, class _CharT, class _Traits, class _Dist>
> inline bool
> operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
> const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
> { return !__x._M_equal(__y); }
># 152 "/usr/include/c++/8/bits/stream_iterator.h" 3
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT> >
> class ostream_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> private:
> ostream_type* _M_stream;
> const _CharT* _M_string;
>
> public:
>
> ostream_iterator(ostream_type& __s)
> : _M_stream(std::__addressof(__s)), _M_string(0) {}
># 184 "/usr/include/c++/8/bits/stream_iterator.h" 3
> ostream_iterator(ostream_type& __s, const _CharT* __c)
> : _M_stream(&__s), _M_string(__c) { }
>
>
> ostream_iterator(const ostream_iterator& __obj)
> : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
>
>
>
> ostream_iterator&
> operator=(const _Tp& __value)
> {
>
>
> ;
> *_M_stream << __value;
> if (_M_string) *_M_stream << _M_string;
> return *this;
> }
>
> ostream_iterator&
> operator*()
> { return *this; }
>
> ostream_iterator&
> operator++()
> { return *this; }
>
> ostream_iterator&
> operator++(int)
> { return *this; }
> };
>
>
>
>
>}
># 67 "/usr/include/c++/8/iterator" 2 3
># 15 "/usr/local/include/fmt/core.h" 2 3
># 200 "/usr/local/include/fmt/core.h" 3
>namespace fmt { inline namespace v5 {
>
>
>namespace internal {
>template <typename T>
>typename std::add_rvalue_reference<T>::type declval() noexcept;
>}
># 215 "/usr/local/include/fmt/core.h" 3
>template <typename Char>
>class basic_string_view {
> private:
> const Char *data_;
> size_t size_;
>
> public:
> typedef Char char_type;
> typedef const Char *iterator;
>
>
>
> typedef std::basic_string_view<Char> type;
># 237 "/usr/local/include/fmt/core.h" 3
> constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
>
>
> constexpr basic_string_view(const Char *s, size_t count) noexcept
> : data_(s), size_(count) {}
>
>
>
>
>
>
>
> basic_string_view(const Char *s)
> : data_(s), size_(std::char_traits<Char>::length(s)) {}
>
>
> template <typename Alloc>
> constexpr basic_string_view(
> const std::basic_string<Char, Alloc> &s) noexcept
> : data_(s.c_str()), size_(s.size()) {}
>
> constexpr basic_string_view(type s) noexcept
> : data_(s.data()), size_(s.size()) {}
>
>
> const Char *data() const { return data_; }
>
>
> constexpr size_t size() const { return size_; }
>
> constexpr iterator begin() const { return data_; }
> constexpr iterator end() const { return data_ + size_; }
>
> constexpr void remove_prefix(size_t n) {
> data_ += n;
> size_ -= n;
> }
>
>
> int compare(basic_string_view other) const {
> size_t str_size = size_ < other.size_ ? size_ : other.size_;
> int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
> if (result == 0)
> result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
> return result;
> }
>
> friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
> return lhs.compare(rhs) == 0;
> }
> friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
> return lhs.compare(rhs) != 0;
> }
> friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
> return lhs.compare(rhs) < 0;
> }
> friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
> return lhs.compare(rhs) <= 0;
> }
> friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
> return lhs.compare(rhs) > 0;
> }
> friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
> return lhs.compare(rhs) >= 0;
> }
>};
>
>typedef basic_string_view<char> string_view;
>typedef basic_string_view<wchar_t> wstring_view;
>
>template <typename Context>
>class basic_format_arg;
>
>template <typename Context>
>class basic_format_args;
>
>
>template <typename T, typename Char = char, typename Enable = void>
>struct formatter;
>
>namespace internal {
>
>
>template <typename T>
>class basic_buffer {
> private:
> basic_buffer(const basic_buffer &) = delete; void operator=(const basic_buffer &) = delete;
>
> T *ptr_;
> std::size_t size_;
> std::size_t capacity_;
>
> protected:
> basic_buffer(T *p = nullptr, std::size_t buf_size = 0, std::size_t buf_capacity = 0)
> noexcept: ptr_(p), size_(buf_size), capacity_(buf_capacity) {}
>
>
> void set(T *buf_data, std::size_t buf_capacity) noexcept {
> ptr_ = buf_data;
> capacity_ = buf_capacity;
> }
>
>
> virtual void grow(std::size_t capacity) = 0;
>
> public:
> typedef T value_type;
> typedef const T &const_reference;
>
> virtual ~basic_buffer() {}
>
> T *begin() noexcept { return ptr_; }
> T *end() noexcept { return ptr_ + size_; }
>
>
> std::size_t size() const noexcept { return size_; }
>
>
> std::size_t capacity() const noexcept { return capacity_; }
>
>
> T *data() noexcept { return ptr_; }
>
>
> const T *data() const noexcept { return ptr_; }
>
>
>
>
> void resize(std::size_t new_size) {
> reserve(new_size);
> size_ = new_size;
> }
>
>
> void reserve(std::size_t new_capacity) {
> if (new_capacity > capacity_)
> grow(new_capacity);
> }
>
> void push_back(const T &value) {
> reserve(size_ + 1);
> ptr_[size_++] = value;
> }
>
>
> template <typename U>
> void append(const U *begin, const U *end);
>
> T &operator[](std::size_t index) { return ptr_[index]; }
> const T &operator[](std::size_t index) const { return ptr_[index]; }
>};
>
>typedef basic_buffer<char> buffer;
>typedef basic_buffer<wchar_t> wbuffer;
>
>
>template <typename Container>
>class container_buffer : public basic_buffer<typename Container::value_type> {
> private:
> Container &container_;
>
> protected:
> void grow(std::size_t capacity) override {
> container_.resize(capacity);
> this->set(&container_[0], capacity);
> }
>
> public:
> explicit container_buffer(Container &c)
> : basic_buffer<typename Container::value_type>(&c[0], c.size(), c.size()),
> container_(c) {}
>};
>
>struct error_handler {
> constexpr error_handler() {}
> constexpr error_handler(const error_handler &) {}
>
>
> void on_error(const char *message);
>};
>
>
>
>
>
>template <typename Char>
>inline void require_wchar() {
> static_assert(
> std::is_same<wchar_t, Char>::value,
> "formatting of wide characters into a narrow output is disallowed");
>}
>
>template <typename Char>
>struct named_arg_base;
>
>template <typename T, typename Char>
>struct named_arg;
>
>template <typename T>
>struct is_named_arg : std::false_type {};
>
>template <typename T, typename Char>
>struct is_named_arg<named_arg<T, Char>> : std::true_type {};
>
>enum type {
> none_type, named_arg_type,
>
> int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
> last_integer_type = char_type,
>
> double_type, long_double_type, last_numeric_type = long_double_type,
> cstring_type, string_type, pointer_type, custom_type
>};
>
>constexpr bool is_integral(type t) {
> (static_cast <bool> ((t != internal::named_arg_type) && "invalid argument type") ? void (0) : __assert_fail ("(t != internal::named_arg_type) && \"invalid argument type\"", "/usr/local/include/fmt/core.h", 453, __extension__ __PRETTY_FUNCTION__));
> return t > internal::none_type && t <= internal::last_integer_type;
>}
>
>constexpr bool is_arithmetic(type t) {
> (static_cast <bool> ((t != internal::named_arg_type) && "invalid argument type") ? void (0) : __assert_fail ("(t != internal::named_arg_type) && \"invalid argument type\"", "/usr/local/include/fmt/core.h", 458, __extension__ __PRETTY_FUNCTION__));
> return t > internal::none_type && t <= internal::last_numeric_type;
>}
>
>template <typename T, typename Char, bool ENABLE = true>
>struct convert_to_int {
> enum {
> value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
> };
>};
>
>template <typename Char>
>struct string_value {
> const Char *value;
> std::size_t size;
>};
>
>template <typename Context>
>struct custom_value {
> const void *value;
> void (*format)(const void *arg, Context &ctx);
>};
>
>
>template <typename Context>
>class value {
> public:
> typedef typename Context::char_type char_type;
>
> union {
> int int_value;
> unsigned uint_value;
> long long long_long_value;
> unsigned long long ulong_long_value;
> double double_value;
> long double long_double_value;
> const void *pointer;
> string_value<char_type> string;
> string_value<signed char> sstring;
> string_value<unsigned char> ustring;
> custom_value<Context> custom;
> };
>
> constexpr value(int val = 0) : int_value(val) {}
> value(unsigned val) { uint_value = val; }
> value(long long val) { long_long_value = val; }
> value(unsigned long long val) { ulong_long_value = val; }
> value(double val) { double_value = val; }
> value(long double val) { long_double_value = val; }
> value(const char_type *val) { string.value = val; }
> value(const signed char *val) {
> static_assert(std::is_same<char, char_type>::value,
> "incompatible string types");
> sstring.value = val;
> }
> value(const unsigned char *val) {
> static_assert(std::is_same<char, char_type>::value,
> "incompatible string types");
> ustring.value = val;
> }
> value(basic_string_view<char_type> val) {
> string.value = val.data();
> string.size = val.size();
> }
> value(const void *val) { pointer = val; }
>
> template <typename T>
> explicit value(const T &val) {
> custom.value = &val;
> custom.format = &format_custom_arg<T>;
> }
>
> const named_arg_base<char_type> &as_named_arg() {
> return *static_cast<const named_arg_base<char_type>*>(pointer);
> }
>
> private:
>
> template <typename T>
> static void format_custom_arg(const void *arg, Context &ctx) {
>
>
>
> typename Context::template formatter_type<T>::type f;
> auto &&parse_ctx = ctx.parse_context();
> parse_ctx.advance_to(f.parse(parse_ctx));
> ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
> }
>};
>
>template <typename Context, type TYPE>
>struct typed_value : value<Context> {
> static const type type_tag = TYPE;
>
> template <typename T>
> constexpr typed_value(const T &val) : value<Context>(val) {}
>};
>
>template <typename Context, typename T>
>constexpr basic_format_arg<Context> make_arg(const T &value);
># 571 "/usr/local/include/fmt/core.h" 3
>template <typename C> constexpr typed_value<C, bool_type> make_value(bool val) { return static_cast<int>(val); }
>template <typename C> constexpr typed_value<C, int_type> make_value(short val) { return static_cast<int>(val); }
>template <typename C> constexpr typed_value<C, uint_type> make_value(unsigned short val) { return static_cast<unsigned>(val); }
>template <typename C> constexpr typed_value<C, int_type> make_value(int val) { return val; }
>template <typename C> constexpr typed_value<C, uint_type> make_value(unsigned val) { return val; }
>
>
>
>typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
> long_type;
>template <typename C> constexpr typed_value<C, (sizeof(long) == sizeof(int) ? int_type : long_long_type)> make_value(long val) { return static_cast<long_type>(val); }
>
>typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
> unsigned, unsigned long long>::type ulong_type;
>template <typename C> constexpr typed_value<C, (sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type)> make_value(unsigned long val) { return static_cast<ulong_type>(val); }
>
>
>
>template <typename C> constexpr typed_value<C, long_long_type> make_value(long long val) { return val; }
>template <typename C> constexpr typed_value<C, ulong_long_type> make_value(unsigned long long val) { return val; }
>template <typename C> constexpr typed_value<C, int_type> make_value(signed char val) { return static_cast<int>(val); }
>template <typename C> constexpr typed_value<C, uint_type> make_value(unsigned char val) { return static_cast<unsigned>(val); }
>template <typename C> constexpr typed_value<C, char_type> make_value(char val) { return static_cast<int>(val); }
>
>
>template <typename C>
>inline typed_value<C, char_type> make_value(wchar_t val) {
> require_wchar<typename C::char_type>();
> return static_cast<int>(val);
>}
>
>
>template <typename C> constexpr typed_value<C, double_type> make_value(float val) { return static_cast<double>(val); }
>template <typename C> constexpr typed_value<C, double_type> make_value(double val) { return val; }
>template <typename C> constexpr typed_value<C, long_double_type> make_value(long double val) { return val; }
>
>
>
>template <typename C> constexpr typed_value<C, cstring_type> make_value(typename C::char_type* val) { return static_cast<const typename C::char_type*>(val); }
>
>template <typename C> constexpr typed_value<C, cstring_type> make_value(const typename C::char_type* val) { return static_cast<const typename C::char_type*>(val); }
>
>
>template <typename C> constexpr typed_value<C, cstring_type> make_value(signed char* val) { return static_cast<const signed char*>(val); }
>template <typename C> constexpr typed_value<C, cstring_type> make_value(const signed char* val) { return val; }
>template <typename C> constexpr typed_value<C, cstring_type> make_value(unsigned char* val) { return static_cast<const unsigned char*>(val); }
>template <typename C> constexpr typed_value<C, cstring_type> make_value(const unsigned char* val) { return val; }
>template <typename C> constexpr typed_value<C, string_type> make_value(basic_string_view<typename C::char_type> val) { return val; }
>template <typename C> constexpr typed_value<C, string_type> make_value(typename basic_string_view<typename C::char_type>::type val) { return static_cast<basic_string_view<typename C::char_type> >(val); }
>
>
>template <typename C> constexpr typed_value<C, string_type> make_value(const std::basic_string<typename C::char_type>& val) { return static_cast<basic_string_view<typename C::char_type> >(val); }
>
>template <typename C> constexpr typed_value<C, pointer_type> make_value(void* val) { return static_cast<const void*>(val); }
>template <typename C> constexpr typed_value<C, pointer_type> make_value(const void* val) { return val; }
>
>
>template <typename C> constexpr typed_value<C, pointer_type> make_value(std::nullptr_t val) { return static_cast<const void*>(val); }
>
>
>
>
>
>
>template <typename C, typename T>
>typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type
> make_value(const T *) {
> static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
>}
>
>template <typename C, typename T>
>inline typename std::enable_if<
> std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
> typed_value<C, int_type>>::type
> make_value(const T &val) { return static_cast<int>(val); }
>
>template <typename C, typename T, typename Char = typename C::char_type>
>inline typename std::enable_if<
> !convert_to_int<T, Char>::value &&
> !std::is_convertible<T, basic_string_view<Char>>::value,
>
>
> typed_value<C, custom_type>>::type
> make_value(const T &val) { return val; }
>
>template <typename C, typename T>
>typed_value<C, named_arg_type>
> make_value(const named_arg<T, typename C::char_type> &val) {
> basic_format_arg<C> arg = make_arg<C>(val.value);
> std::memcpy(val.data, &arg, sizeof(arg));
> return static_cast<const void*>(&val);
>}
>
>
>enum { max_packed_args = 15 };
>
>template <typename Context>
>class arg_map;
>
>template <typename>
>struct result_of;
>
>template <typename F, typename... Args>
>struct result_of<F(Args...)> {
>
> typedef typename std::result_of<
> typename std::remove_reference<F>::type(Args...)>::type type;
>};
>}
>
>
>
>template <typename Context>
>class basic_format_arg {
> private:
> internal::value<Context> value_;
> internal::type type_;
>
> template <typename ContextType, typename T>
> friend constexpr basic_format_arg<ContextType>
> internal::make_arg(const T &value);
>
> template <typename Visitor, typename Ctx>
> friend constexpr typename internal::result_of<Visitor(int)>::type
> visit(Visitor &&vis, basic_format_arg<Ctx> arg);
>
> friend class basic_format_args<Context>;
> friend class internal::arg_map<Context>;
>
> typedef typename Context::char_type char_type;
>
> public:
> class handle {
> public:
> explicit handle(internal::custom_value<Context> custom): custom_(custom) {}
>
> void format(Context &ctx) const { custom_.format(custom_.value, ctx); }
>
> private:
> internal::custom_value<Context> custom_;
> };
>
> constexpr basic_format_arg() : type_(internal::none_type) {}
>
> operator bool() const noexcept {
> return type_ != internal::none_type;
> }
>
> internal::type type() const { return type_; }
>
> bool is_integral() const { return internal::is_integral(type_); }
> bool is_arithmetic() const { return internal::is_arithmetic(type_); }
>};
>
>
>
>template <typename Char, typename ErrorHandler = internal::error_handler>
>class basic_parse_context : private ErrorHandler {
> private:
> basic_string_view<Char> format_str_;
> int next_arg_id_;
>
> public:
> typedef Char char_type;
> typedef typename basic_string_view<Char>::iterator iterator;
>
> explicit constexpr basic_parse_context(
> basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
> : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
>
>
>
> constexpr iterator begin() const noexcept {
> return format_str_.begin();
> }
>
>
> constexpr iterator end() const noexcept { return format_str_.end(); }
>
>
> constexpr void advance_to(iterator it) {
> format_str_.remove_prefix(it - begin());
> }
>
>
> constexpr unsigned next_arg_id();
>
> constexpr bool check_arg_id(unsigned) {
> if (next_arg_id_ > 0) {
> on_error("cannot switch from automatic to manual argument indexing");
> return false;
> }
> next_arg_id_ = -1;
> return true;
> }
> void check_arg_id(basic_string_view<Char>) {}
>
> constexpr void on_error(const char *message) {
> ErrorHandler::on_error(message);
> }
>
> constexpr ErrorHandler error_handler() const { return *this; }
>};
>
>typedef basic_parse_context<char> parse_context;
>typedef basic_parse_context<wchar_t> wparse_context;
>
>namespace internal {
>
>template <typename Context>
>class arg_map {
> private:
> arg_map(const arg_map &) = delete; void operator=(const arg_map &) = delete;
>
> typedef typename Context::char_type char_type;
>
> struct entry {
> basic_string_view<char_type> name;
> basic_format_arg<Context> arg;
> };
>
> entry *map_;
> unsigned size_;
>
> void push_back(value<Context> val) {
> const internal::named_arg_base<char_type> &named = val.as_named_arg();
> map_[size_] = entry{named.name, named.template deserialize<Context>()};
> ++size_;
> }
>
> public:
> arg_map() : map_(nullptr), size_(0) {}
> void init(const basic_format_args<Context> &args);
> ~arg_map() { delete [] map_; }
>
> basic_format_arg<Context> find(basic_string_view<char_type> name) const {
>
> for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
> if (it->name == name)
> return it->arg;
> }
> return basic_format_arg<Context>();
> }
>};
>
>template <typename OutputIt, typename Context, typename Char>
>class context_base {
> public:
> typedef OutputIt iterator;
>
> private:
> basic_parse_context<Char> parse_context_;
> iterator out_;
> basic_format_args<Context> args_;
>
> protected:
> typedef Char char_type;
> typedef basic_format_arg<Context> format_arg;
>
> context_base(OutputIt out, basic_string_view<char_type> format_str,
> basic_format_args<Context> ctx_args)
> : parse_context_(format_str), out_(out), args_(ctx_args) {}
>
>
> format_arg do_get_arg(unsigned arg_id) {
> format_arg arg = args_.get(arg_id);
> if (!arg)
> parse_context_.on_error("argument index out of range");
> return arg;
> }
>
>
>
> format_arg get_arg(unsigned arg_id) {
> return this->parse_context().check_arg_id(arg_id) ?
> this->do_get_arg(arg_id) : format_arg();
> }
>
> public:
> basic_parse_context<char_type> &parse_context() {
> return parse_context_;
> }
>
> internal::error_handler error_handler() {
> return parse_context_.error_handler();
> }
>
> void on_error(const char *message) { parse_context_.on_error(message); }
>
>
> iterator out() { return out_; }
> iterator begin() { return out_; }
>
>
> void advance_to(iterator it) { out_ = it; }
>
> basic_format_args<Context> args() const { return args_; }
>};
>
>
>template <typename Container>
>inline Container &get_container(std::back_insert_iterator<Container> it) {
> typedef std::back_insert_iterator<Container> bi_iterator;
> struct accessor: bi_iterator {
> accessor(bi_iterator iter) : bi_iterator(iter) {}
> using bi_iterator::container;
> };
> return *accessor(it).container;
>}
>}
>
>
>template <typename OutputIt, typename Char>
>class basic_format_context :
> public internal::context_base<
> OutputIt, basic_format_context<OutputIt, Char>, Char> {
> public:
>
> typedef Char char_type;
>
>
> template <typename T>
> struct formatter_type { typedef formatter<T, char_type> type; };
>
> private:
> internal::arg_map<basic_format_context> map_;
>
> basic_format_context(const basic_format_context &) = delete; void operator=(const basic_format_context &) = delete;
>
> typedef internal::context_base<OutputIt, basic_format_context, Char> base;
> typedef typename base::format_arg format_arg;
> using base::get_arg;
>
> public:
> using typename base::iterator;
>
>
>
>
>
> basic_format_context(OutputIt out, basic_string_view<char_type> format_str,
> basic_format_args<basic_format_context> ctx_args)
> : base(out, format_str, ctx_args) {}
>
> format_arg next_arg() {
> return this->do_get_arg(this->parse_context().next_arg_id());
> }
> format_arg get_arg(unsigned arg_id) { return this->do_get_arg(arg_id); }
>
>
>
> format_arg get_arg(basic_string_view<char_type> name);
>};
>
>template <typename Char>
>struct buffer_context {
> typedef basic_format_context<
> std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
>};
>typedef buffer_context<char>::type format_context;
>typedef buffer_context<wchar_t>::type wformat_context;
>
>namespace internal {
>template <typename Context, typename T>
>struct get_type {
> typedef decltype(make_value<Context>(
> declval<typename std::decay<T>::type&>())) value_type;
> static const type value = value_type::type_tag;
>};
>
>template <typename Context>
>constexpr uint64_t get_types() { return 0; }
>
>template <typename Context, typename Arg, typename... Args>
>constexpr uint64_t get_types() {
> return get_type<Context, Arg>::value | (get_types<Context, Args...>() << 4);
>}
>
>template <typename Context, typename T>
>constexpr basic_format_arg<Context> make_arg(const T &value) {
> basic_format_arg<Context> arg;
> arg.type_ = get_type<Context, T>::value;
> arg.value_ = make_value<Context>(value);
> return arg;
>}
>
>template <bool IS_PACKED, typename Context, typename T>
>inline typename std::enable_if<IS_PACKED, value<Context>>::type
> make_arg(const T &value) {
> return make_value<Context>(value);
>}
>
>template <bool IS_PACKED, typename Context, typename T>
>inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
> make_arg(const T &value) {
> return make_arg<Context>(value);
>}
>}
># 977 "/usr/local/include/fmt/core.h" 3
>template <typename Context, typename ...Args>
>class format_arg_store {
> private:
> static const size_t NUM_ARGS = sizeof...(Args);
>
>
> static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
>
> typedef typename std::conditional<IS_PACKED,
> internal::value<Context>, basic_format_arg<Context>>::type value_type;
>
>
> value_type data_[NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1)];
>
> friend class basic_format_args<Context>;
>
> static constexpr int64_t get_types() {
> return IS_PACKED ?
> static_cast<int64_t>(internal::get_types<Context, Args...>()) :
> -static_cast<int64_t>(NUM_ARGS);
> }
>
> public:
>
> static constexpr int64_t TYPES = get_types();
># 1012 "/usr/local/include/fmt/core.h" 3
> format_arg_store(const Args &... args)
> : data_{internal::make_arg<IS_PACKED, Context>(args)...} {}
>
>};
># 1029 "/usr/local/include/fmt/core.h" 3
>template <typename Context, typename ...Args>
>inline format_arg_store<Context, Args...>
> make_format_args(const Args & ... args) {
> return format_arg_store<Context, Args...>(args...);
>}
>
>template <typename ...Args>
>inline format_arg_store<format_context, Args...>
> make_format_args(const Args & ... args) {
> return format_arg_store<format_context, Args...>(args...);
>}
>
>
>template <typename Context>
>class basic_format_args {
> public:
> typedef unsigned size_type;
> typedef basic_format_arg<Context> format_arg;
>
> private:
>
>
> uint64_t types_;
> union {
>
>
>
>
>
> const internal::value<Context> *values_;
> const format_arg *args_;
> };
>
> typename internal::type type(unsigned index) const {
> unsigned shift = index * 4;
> uint64_t mask = 0xf;
> return static_cast<typename internal::type>(
> (types_ & (mask << shift)) >> shift);
> }
>
> friend class internal::arg_map<Context>;
>
> void set_data(const internal::value<Context> *values) { values_ = values; }
> void set_data(const format_arg *args) { args_ = args; }
>
> format_arg do_get(size_type index) const {
> int64_t signed_types = static_cast<int64_t>(types_);
> if (signed_types < 0) {
> uint64_t num_args = -signed_types;
> return index < num_args ? args_[index] : format_arg();
> }
> format_arg arg;
> if (index > internal::max_packed_args)
> return arg;
> arg.type_ = type(index);
> if (arg.type_ == internal::none_type)
> return arg;
> internal::value<Context> &val = arg.value_;
> val = values_[index];
> return arg;
> }
>
> public:
> basic_format_args() : types_(0) {}
>
>
>
>
>
>
> template <typename... Args>
> basic_format_args(const format_arg_store<Context, Args...> &store)
> : types_(store.TYPES) {
> set_data(store.data_);
> }
>
>
> format_arg get(size_type index) const {
> format_arg arg = do_get(index);
> return arg.type_ == internal::named_arg_type ?
> arg.value_.as_named_arg().template deserialize<Context>() : arg;
> }
>
> unsigned max_size() const {
> int64_t signed_types = static_cast<int64_t>(types_);
> return static_cast<unsigned>(
> signed_types < 0 ?
> -signed_types : static_cast<int64_t>(internal::max_packed_args));
> }
>};
>
>
>
>struct format_args: basic_format_args<format_context> {
> template <typename ...Args>
> format_args(Args && ... arg)
> : basic_format_args<format_context>(std::forward<Args>(arg)...) {}
>};
>struct wformat_args : basic_format_args<wformat_context> {
> template <typename ...Args>
> wformat_args(Args && ... arg)
> : basic_format_args<wformat_context>(std::forward<Args>(arg)...) {}
>};
>
>namespace internal {
>template <typename Char>
>struct named_arg_base {
> basic_string_view<Char> name;
>
>
> mutable char data[sizeof(basic_format_arg<format_context>)];
>
> named_arg_base(basic_string_view<Char> nm) : name(nm) {}
>
> template <typename Context>
> basic_format_arg<Context> deserialize() const {
> basic_format_arg<Context> arg;
> std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
> return arg;
> }
>};
>
>template <typename T, typename Char>
>struct named_arg : named_arg_base<Char> {
> const T &value;
>
> named_arg(basic_string_view<Char> name, const T &val)
> : named_arg_base<Char>(name), value(val) {}
>};
>}
># 1169 "/usr/local/include/fmt/core.h" 3
>template <typename T>
>inline internal::named_arg<T, char> arg(string_view name, const T &arg) {
> return internal::named_arg<T, char>(name, arg);
>}
>
>template <typename T>
>inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg) {
> return internal::named_arg<T, wchar_t>(name, arg);
>}
>
>
>
>template <typename S, typename T, typename Char>
>void arg(S, internal::named_arg<T, Char>) = delete;
>
>
>
>enum color { black, red, green, yellow, blue, magenta, cyan, white };
>
> void vprint_colored(color c, string_view format, format_args args);
> void vprint_colored(color c, wstring_view format, wformat_args args);
>
>
>
>
>
>
>
>template <typename... Args>
>inline void print_colored(color c, string_view format_str,
> const Args & ... args) {
> vprint_colored(c, format_str, make_format_args(args...));
>}
>
>template <typename... Args>
>inline void print_colored(color c, wstring_view format_str,
> const Args & ... args) {
> vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
>}
># 1396 "/usr/local/include/fmt/core.h" 3
>format_context::iterator vformat_to(
> internal::buffer &buf, string_view format_str, format_args args);
>wformat_context::iterator vformat_to(
> internal::wbuffer &buf, wstring_view format_str, wformat_args args);
>
>template <typename Container>
>struct is_contiguous : std::false_type {};
>
>template <typename Char>
>struct is_contiguous<std::basic_string<Char>> : std::true_type {};
>
>template <typename Char>
>struct is_contiguous<internal::basic_buffer<Char>> : std::true_type {};
>
>
>template <typename Container>
>typename std::enable_if<
> is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
> vformat_to(std::back_insert_iterator<Container> out,
> string_view format_str, format_args args) {
> auto& container = internal::get_container(out);
> internal::container_buffer<Container> buf(container);
> vformat_to(buf, format_str, args);
> return std::back_inserter(container);
>}
>
>template <typename Container>
>typename std::enable_if<
> is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
> vformat_to(std::back_insert_iterator<Container> out,
> wstring_view format_str, wformat_args args) {
> auto& container = internal::get_container(out);
> internal::container_buffer<Container> buf(container);
> vformat_to(buf, format_str, args);
> return std::back_inserter(container);
>}
>
>std::string vformat(string_view format_str, format_args args);
>std::wstring vformat(wstring_view format_str, wformat_args args);
># 1446 "/usr/local/include/fmt/core.h" 3
>template <typename... Args>
>inline std::string format(string_view format_str, const Args & ... args) {
>
>
>
> format_arg_store<format_context, Args...> as{args...};
> return vformat(format_str, as);
>}
>template <typename... Args>
>inline std::wstring format(wstring_view format_str, const Args & ... args) {
> format_arg_store<wformat_context, Args...> as{args...};
> return vformat(format_str, as);
>}
>
> void vprint(std::FILE *f, string_view format_str, format_args args);
> void vprint(std::FILE *f, wstring_view format_str, wformat_args args);
># 1472 "/usr/local/include/fmt/core.h" 3
>template <typename... Args>
>inline void print(std::FILE *f, string_view format_str, const Args & ... args) {
> format_arg_store<format_context, Args...> as(args...);
> vprint(f, format_str, as);
>}
>
>
>
>
>template <typename... Args>
>inline void print(std::FILE *f, wstring_view format_str, const Args & ... args) {
> format_arg_store<wformat_context, Args...> as(args...);
> vprint(f, format_str, as);
>}
>
> void vprint(string_view format_str, format_args args);
> void vprint(wstring_view format_str, wformat_args args);
># 1499 "/usr/local/include/fmt/core.h" 3
>template <typename... Args>
>inline void print(string_view format_str, const Args & ... args) {
> format_arg_store<format_context, Args...> as{args...};
> vprint(format_str, as);
>}
>
>template <typename... Args>
>inline void print(wstring_view format_str, const Args & ... args) {
> format_arg_store<wformat_context, Args...> as(args...);
> vprint(format_str, as);
>}
>}}
># 55 "/usr/local/include/fmt/format.h" 2 3
>
>
>#pragma GCC diagnostic push
>
>
>
>#pragma GCC diagnostic ignored "-Wshadow"
>
>
>
>#pragma GCC diagnostic ignored "-Wsign-conversion"
># 232 "/usr/local/include/fmt/format.h" 3
>namespace fmt { inline namespace v5 {
>namespace internal {
>
>
>
>
>template <typename Dest, typename Source>
>inline Dest bit_cast(const Source& source) {
> static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
> Dest dest;
> std::memcpy(&dest, &source, sizeof(dest));
> return dest;
>}
>
>
>template <typename C>
>constexpr auto begin(const C &c) -> decltype(c.begin()) {
> return c.begin();
>}
>template <typename T, std::size_t N>
>constexpr T *begin(T (&array)[N]) noexcept { return array; }
>template <typename C>
>constexpr auto end(const C &c) -> decltype(c.end()) { return c.end(); }
>template <typename T, std::size_t N>
>constexpr T *end(T (&array)[N]) noexcept { return array + N; }
>
>
>template <typename Result>
>struct function {
> template <typename T>
> struct result { typedef Result type; };
>};
>
>struct dummy_int {
> int data[2];
> operator int() const { return 0; }
>};
>typedef std::numeric_limits<internal::dummy_int> fputil;
>
>
>
>inline dummy_int signbit(...) { return dummy_int(); }
>inline dummy_int _ecvt_s(...) { return dummy_int(); }
>inline dummy_int isinf(...) { return dummy_int(); }
>inline dummy_int _finite(...) { return dummy_int(); }
>inline dummy_int isnan(...) { return dummy_int(); }
>inline dummy_int _isnan(...) { return dummy_int(); }
>
>
>class fp {
> private:
> typedef uint64_t significand_type;
>
>
> static constexpr const int char_size =
> std::numeric_limits<unsigned char>::digits;
>
>
> static constexpr const int double_significand_size =
> std::numeric_limits<double>::digits - 1;
> static constexpr const uint64_t implicit_bit =
> 1ull << double_significand_size;
>
> public:
> significand_type f;
> int e;
>
> static constexpr const int significand_size =
> sizeof(significand_type) * char_size;
>
> fp(uint64_t f, int e): f(f), e(e) {}
>
>
>
> template <typename Double>
> explicit fp(Double d) {
>
> typedef std::numeric_limits<Double> limits;
> const int double_size = sizeof(Double) * char_size;
> const int exponent_size =
> double_size - double_significand_size - 1;
> const uint64_t significand_mask = implicit_bit - 1;
> const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
> const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
> auto u = bit_cast<uint64_t>(d);
> auto biased_e = (u & exponent_mask) >> double_significand_size;
> f = u & significand_mask;
> if (biased_e != 0)
> f += implicit_bit;
> else
> biased_e = 1;
> e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
> }
>
>
> template <int SHIFT = 0>
> void normalize() {
>
> auto shifted_implicit_bit = implicit_bit << SHIFT;
> while ((f & shifted_implicit_bit) == 0) {
> f <<= 1;
> --e;
> }
>
> auto offset = significand_size - double_significand_size - SHIFT - 1;
> f <<= offset;
> e -= offset;
> }
>};
>
>
>inline fp operator-(fp x, fp y) {
> (static_cast <bool> ((x.f >= y.f && x.e == y.e) && "invalid operands") ? void (0) : __assert_fail ("(x.f >= y.f && x.e == y.e) && \"invalid operands\"", "/usr/local/include/fmt/format.h", 344, __extension__ __PRETTY_FUNCTION__));
> return fp(x.f - y.f, x.e);
>}
>
>
>
>fp operator*(fp x, fp y);
>
>
>
>fp get_cached_power(int min_exponent, int &pow10_exponent);
>
>template <typename Allocator>
>typename Allocator::value_type *allocate(Allocator& alloc, std::size_t n) {
>
> return std::allocator_traits<Allocator>::allocate(alloc, n);
>
>
>
>}
>
>
>
>template <typename T>
>inline T const_check(T value) { return value; }
>}
>}}
>
>namespace std {
>
>
>
>
>template <>
>class numeric_limits<fmt::internal::dummy_int> :
> public std::numeric_limits<int> {
> public:
>
> template <typename T>
> static bool isinfinity(T x) {
> using namespace fmt::internal;
>
>
> if (const_check(sizeof(isinf(x)) != sizeof(dummy_int)))
> return isinf(x) != 0;
> return !_finite(static_cast<double>(x));
> }
>
>
> template <typename T>
> static bool isnotanumber(T x) {
> using namespace fmt::internal;
> if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_int)))
> return isnan(x) != 0;
> return _isnan(static_cast<double>(x)) != 0;
> }
>
>
> static bool isnegative(double x) {
> using namespace fmt::internal;
> if (const_check(sizeof(signbit(x)) != sizeof(fmt::internal::dummy_int)))
> return signbit(x) != 0;
> if (x < 0) return true;
> if (!isnotanumber(x)) return false;
> int dec = 0, sign = 0;
> char buffer[2];
> _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
> return sign != 0;
> }
>};
>}
>
>namespace fmt { inline namespace v5 {
>template <typename Range>
>class basic_writer;
>
>template <typename OutputIt, typename T = typename OutputIt::value_type>
>class output_range {
> private:
> OutputIt it_;
>
>
> typedef void sentinel;
> sentinel end() const;
>
> public:
> typedef OutputIt iterator;
> typedef T value_type;
>
> explicit output_range(OutputIt it): it_(it) {}
> OutputIt begin() const { return it_; }
>};
>
>
>template <typename Container>
>class back_insert_range:
> public output_range<std::back_insert_iterator<Container>> {
> typedef output_range<std::back_insert_iterator<Container>> base;
> public:
> typedef typename Container::value_type value_type;
>
> back_insert_range(Container &c): base(std::back_inserter(c)) {}
> back_insert_range(typename base::iterator it): base(it) {}
>};
>
>typedef basic_writer<back_insert_range<internal::buffer>> writer;
>typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
>
>
>class format_error : public std::runtime_error {
> public:
> explicit format_error(const char *message)
> : std::runtime_error(message) {}
>
> explicit format_error(const std::string &message)
> : std::runtime_error(message) {}
>};
>
>namespace internal {
>
>
>template <typename Int>
>constexpr typename std::make_unsigned<Int>::type to_unsigned(Int value) {
> (static_cast <bool> ((value >= 0) && "negative value") ? void (0) : __assert_fail ("(value >= 0) && \"negative value\"", "/usr/local/include/fmt/format.h", 467, __extension__ __PRETTY_FUNCTION__));
> return static_cast<typename std::make_unsigned<Int>::type>(value);
>}
># 481 "/usr/local/include/fmt/format.h" 3
>template <typename T>
>struct checked { typedef T *type; };
>template <typename T>
>inline T *make_checked(T *p, std::size_t) { return p; }
>
>
>template <typename T>
>template <typename U>
>void basic_buffer<T>::append(const U *begin, const U *end) {
> std::size_t new_size = size_ + internal::to_unsigned(end - begin);
> reserve(new_size);
> std::uninitialized_copy(begin, end,
> internal::make_checked(ptr_, capacity_) + size_);
> size_ = new_size;
>}
>}
>
>
>
>class locale;
>
>class locale_provider {
> public:
> virtual ~locale_provider() {}
> virtual fmt::locale locale();
>};
>
>
>
>enum { inline_buffer_size = 500 };
># 541 "/usr/local/include/fmt/format.h" 3
>template <typename T, std::size_t SIZE = inline_buffer_size,
> typename Allocator = std::allocator<T> >
>class basic_memory_buffer: private Allocator, public internal::basic_buffer<T> {
> private:
> T store_[SIZE];
>
>
> void deallocate() {
> T* data = this->data();
> if (data != store_) Allocator::deallocate(data, this->capacity());
> }
>
> protected:
> void grow(std::size_t size) override;
>
> public:
> explicit basic_memory_buffer(const Allocator &alloc = Allocator())
> : Allocator(alloc) {
> this->set(store_, SIZE);
> }
> ~basic_memory_buffer() { deallocate(); }
>
> private:
>
> void move(basic_memory_buffer &other) {
> Allocator &this_alloc = *this, &other_alloc = other;
> this_alloc = std::move(other_alloc);
> T* data = other.data();
> std::size_t size = other.size(), capacity = other.capacity();
> if (data == other.store_) {
> this->set(store_, capacity);
> std::uninitialized_copy(other.store_, other.store_ + size,
> internal::make_checked(store_, capacity));
> } else {
> this->set(data, capacity);
>
>
> other.set(other.store_, 0);
> }
> this->resize(size);
> }
>
> public:
>
>
>
>
>
>
> basic_memory_buffer(basic_memory_buffer &&other) {
> move(other);
> }
>
>
>
>
>
>
> basic_memory_buffer &operator=(basic_memory_buffer &&other) {
> (static_cast <bool> (this != &other) ? void (0) : __assert_fail ("this != &other", "/usr/local/include/fmt/format.h", 600, __extension__ __PRETTY_FUNCTION__));
> deallocate();
> move(other);
> return *this;
> }
>
>
> Allocator get_allocator() const { return *this; }
>};
>
>template <typename T, std::size_t SIZE, typename Allocator>
>void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
> std::size_t old_capacity = this->capacity();
> std::size_t new_capacity = old_capacity + old_capacity / 2;
> if (size > new_capacity)
> new_capacity = size;
> T *old_data = this->data();
> T *new_data = internal::allocate<Allocator>(*this, new_capacity);
>
> std::uninitialized_copy(old_data, old_data + this->size(),
> internal::make_checked(new_data, new_capacity));
> this->set(new_data, new_capacity);
>
>
>
> if (old_data != store_)
> Allocator::deallocate(old_data, old_capacity);
>}
>
>typedef basic_memory_buffer<char> memory_buffer;
>typedef basic_memory_buffer<wchar_t> wmemory_buffer;
># 641 "/usr/local/include/fmt/format.h" 3
>template <typename Char>
>class basic_fixed_buffer : public internal::basic_buffer<Char> {
> public:
>
>
>
>
>
>
> basic_fixed_buffer(Char *array, std::size_t size) {
> this->set(array, size);
> }
>
>
>
>
>
>
>
> template <std::size_t SIZE>
> explicit basic_fixed_buffer(Char (&array)[SIZE]) {
> this->set(array, SIZE);
> }
>
> protected:
> void grow(std::size_t size) override;
>};
>
>namespace internal {
>
>template <typename Char>
>struct char_traits;
>
>template <>
>struct char_traits<char> {
>
> template <typename T>
> static int format_float(char *buffer, std::size_t size,
> const char *format, int precision, T value);
>};
>
>template <>
>struct char_traits<wchar_t> {
> template <typename T>
> static int format_float(wchar_t *buffer, std::size_t size,
> const wchar_t *format, int precision, T value);
>};
>
>
>extern template int char_traits<char>::format_float<double>(
> char *buffer, std::size_t size, const char* format, int precision,
> double value);
>extern template int char_traits<char>::format_float<long double>(
> char *buffer, std::size_t size, const char* format, int precision,
> long double value);
>
>extern template int char_traits<wchar_t>::format_float<double>(
> wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,
> double value);
>extern template int char_traits<wchar_t>::format_float<long double>(
> wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,
> long double value);
>
>
>template <typename Container>
>inline typename std::enable_if<
> is_contiguous<Container>::value,
> typename checked<typename Container::value_type>::type>::type
> reserve(std::back_insert_iterator<Container> &it, std::size_t n) {
> Container &c = internal::get_container(it);
> std::size_t size = c.size();
> c.resize(size + n);
> return make_checked(&c[size], n);
>}
>
>template <typename Iterator>
>inline Iterator &reserve(Iterator &it, std::size_t) { return it; }
>
>template <typename Char>
>class null_terminating_iterator;
>
>template <typename Char>
>constexpr const Char *pointer_from(null_terminating_iterator<Char> it);
>
>
>
>
>template <typename Char>
>class null_terminating_iterator {
> public:
> typedef std::ptrdiff_t difference_type;
> typedef Char value_type;
> typedef const Char* pointer;
> typedef const Char& reference;
> typedef std::random_access_iterator_tag iterator_category;
>
> null_terminating_iterator() : ptr_(0), end_(0) {}
>
> constexpr null_terminating_iterator(const Char *ptr, const Char *end)
> : ptr_(ptr), end_(end) {}
>
> template <typename Range>
> constexpr explicit null_terminating_iterator(const Range &r)
> : ptr_(r.begin()), end_(r.end()) {}
>
> null_terminating_iterator &operator=(const Char *ptr) {
> (static_cast <bool> (ptr <= end_) ? void (0) : __assert_fail ("ptr <= end_", "/usr/local/include/fmt/format.h", 747, __extension__ __PRETTY_FUNCTION__));
> ptr_ = ptr;
> return *this;
> }
>
> constexpr Char operator*() const {
> return ptr_ != end_ ? *ptr_ : 0;
> }
>
> constexpr null_terminating_iterator operator++() {
> ++ptr_;
> return *this;
> }
>
> constexpr null_terminating_iterator operator++(int) {
> null_terminating_iterator result(*this);
> ++ptr_;
> return result;
> }
>
> constexpr null_terminating_iterator operator--() {
> --ptr_;
> return *this;
> }
>
> constexpr null_terminating_iterator operator+(difference_type n) {
> return null_terminating_iterator(ptr_ + n, end_);
> }
>
> constexpr null_terminating_iterator operator-(difference_type n) {
> return null_terminating_iterator(ptr_ - n, end_);
> }
>
> constexpr null_terminating_iterator operator+=(difference_type n) {
> ptr_ += n;
> return *this;
> }
>
> constexpr difference_type operator-(
> null_terminating_iterator other) const {
> return ptr_ - other.ptr_;
> }
>
> constexpr bool operator!=(null_terminating_iterator other) const {
> return ptr_ != other.ptr_;
> }
>
> bool operator>=(null_terminating_iterator other) const {
> return ptr_ >= other.ptr_;
> }
>
>
>
> template <typename CharT>
> friend constexpr const CharT *pointer_from(
> null_terminating_iterator<CharT> it);
>
> private:
> const Char *ptr_;
> const Char *end_;
>};
>
>template <typename T>
>constexpr const T *pointer_from(const T *p) { return p; }
>
>template <typename Char>
>constexpr const Char *pointer_from(null_terminating_iterator<Char> it) {
> return it.ptr_;
>}
>
>
>
>template <typename T>
>class counting_iterator {
> private:
> std::size_t count_;
> mutable T blackhole_;
>
> public:
> typedef std::output_iterator_tag iterator_category;
> typedef T value_type;
> typedef std::ptrdiff_t difference_type;
> typedef T* pointer;
> typedef T& reference;
> typedef counting_iterator _Unchecked_type;
>
> counting_iterator(): count_(0) {}
>
> std::size_t count() const { return count_; }
>
> counting_iterator& operator++() {
> ++count_;
> return *this;
> }
>
> counting_iterator operator++(int) {
> auto it = *this;
> ++*this;
> return it;
> }
>
> T &operator*() const { return blackhole_; }
>};
>
>
>
>template <typename OutputIt>
>class truncating_iterator {
> private:
> typedef std::iterator_traits<OutputIt> traits;
>
> OutputIt out_;
> std::size_t limit_;
> std::size_t count_;
> mutable typename traits::value_type blackhole_;
>
> public:
> typedef std::output_iterator_tag iterator_category;
> typedef typename traits::value_type value_type;
> typedef typename traits::difference_type difference_type;
> typedef typename traits::pointer pointer;
> typedef typename traits::reference reference;
> typedef truncating_iterator _Unchecked_type;
>
> truncating_iterator(OutputIt out, std::size_t limit)
> : out_(out), limit_(limit), count_(0) {}
>
> OutputIt base() const { return out_; }
> std::size_t count() const { return count_; }
>
> truncating_iterator& operator++() {
> if (count_++ < limit_)
> ++out_;
> return *this;
> }
>
> truncating_iterator operator++(int) {
> auto it = *this;
> ++*this;
> return it;
> }
>
> reference operator*() const { return count_ < limit_ ? *out_ : blackhole_; }
>};
>
>
>
>template <typename T>
>constexpr typename std::enable_if<
> std::numeric_limits<T>::is_signed, bool>::type is_negative(T value) {
> return value < 0;
>}
>template <typename T>
>constexpr typename std::enable_if<
> !std::numeric_limits<T>::is_signed, bool>::type is_negative(T) {
> return false;
>}
>
>template <typename T>
>struct int_traits {
>
>
> typedef typename std::conditional<
> std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>::type main_type;
>};
>
>
>
>template <typename T = void>
>struct basic_data {
> static const uint32_t POWERS_OF_10_32[];
> static const uint64_t POWERS_OF_10_64[];
> static const uint64_t POW10_SIGNIFICANDS[];
> static const int16_t POW10_EXPONENTS[];
> static const char DIGITS[];
>};
>
>
>extern template struct basic_data<void>;
>
>
>typedef basic_data<> data;
>
>
>
>
>inline unsigned count_digits(uint64_t n) {
>
>
> int t = (64 - __builtin_clzll(n | 1)) * 1233 >> 12;
> return to_unsigned(t) - (n < data::POWERS_OF_10_64[t]) + 1;
>}
># 963 "/usr/local/include/fmt/format.h" 3
>template <typename Handler>
>inline char *lg(uint32_t n, Handler h) __attribute__((always_inline));
>
>
>template <typename Handler>
>inline char *lg(uint32_t n, Handler h) {
> return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
> : n < 1000000
> ? n < 10000 ? n < 1000 ? h.template on<2>(n)
> : h.template on<3>(n)
> : n < 100000 ? h.template on<4>(n)
> : h.template on<5>(n)
> : n < 100000000 ? n < 10000000 ? h.template on<6>(n)
> : h.template on<7>(n)
> : n < 1000000000 ? h.template on<8>(n)
> : h.template on<9>(n);
>}
>
>
>
>class decimal_formatter {
> private:
> char *buffer_;
>
> void write_pair(unsigned N, uint32_t index) {
> std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);
> }
>
> public:
> explicit decimal_formatter(char *buf) : buffer_(buf) {}
>
> template <unsigned N> char *on(uint32_t u) {
> if (N == 0) {
> *buffer_ = static_cast<char>(u) + '0';
> } else if (N == 1) {
> write_pair(0, u);
> } else {
>
>
> unsigned n = N - 1;
> unsigned a = n / 5 * n * 53 / 16;
> uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9);
> t = ((t * u) >> a) + n / 5 * 4;
> write_pair(0, t >> 32);
> for (int i = 2; i < N; i += 2) {
> t = 100ULL * static_cast<uint32_t>(t);
> write_pair(i, t >> 32);
> }
> if (N % 2 == 0) {
> buffer_[N] = static_cast<char>(
> (10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
> }
> }
> return buffer_ += N + 1;
> }
>};
>
>
>class decimal_formatter_null : public decimal_formatter {
> public:
> explicit decimal_formatter_null(char *buf) : decimal_formatter(buf) {}
>
> template <unsigned N> char *on(uint32_t u) {
> char *buf = decimal_formatter::on<N>(u);
> *buf = '\0';
> return buf;
> }
>};
>
>
>
>inline unsigned count_digits(uint32_t n) {
> int t = (32 - __builtin_clz(n | 1)) * 1233 >> 12;
> return to_unsigned(t) - (n < data::POWERS_OF_10_32[t]) + 1;
>}
>
>
>
>struct no_thousands_sep {
> typedef char char_type;
>
> template <typename Char>
> void operator()(Char *) {}
>};
>
>
>template <typename Char>
>class add_thousands_sep {
> private:
> basic_string_view<Char> sep_;
>
>
> unsigned digit_index_;
>
> public:
> typedef Char char_type;
>
> explicit add_thousands_sep(basic_string_view<Char> sep)
> : sep_(sep), digit_index_(0) {}
>
> void operator()(Char *&buffer) {
> if (++digit_index_ % 3 != 0)
> return;
> buffer -= sep_.size();
> std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
> internal::make_checked(buffer, sep_.size()));
> }
>};
>
>template <typename Char>
> Char thousands_sep(locale_provider *lp);
>
>
>
>
>template <typename UInt, typename Char, typename ThousandsSep>
>inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits,
> ThousandsSep thousands_sep) {
> buffer += num_digits;
> Char *end = buffer;
> while (value >= 100) {
>
>
>
> unsigned index = static_cast<unsigned>((value % 100) * 2);
> value /= 100;
> *--buffer = data::DIGITS[index + 1];
> thousands_sep(buffer);
> *--buffer = data::DIGITS[index];
> thousands_sep(buffer);
> }
> if (value < 10) {
> *--buffer = static_cast<char>('0' + value);
> return end;
> }
> unsigned index = static_cast<unsigned>(value * 2);
> *--buffer = data::DIGITS[index + 1];
> thousands_sep(buffer);
> *--buffer = data::DIGITS[index];
> return end;
>}
>
>template <typename UInt, typename Iterator, typename ThousandsSep>
>inline Iterator format_decimal(
> Iterator out, UInt value, unsigned num_digits, ThousandsSep sep) {
> typedef typename ThousandsSep::char_type char_type;
>
> char_type buffer[std::numeric_limits<UInt>::digits10 + 2];
> format_decimal(buffer, value, num_digits, sep);
> return std::copy_n(buffer, num_digits, out);
>}
>
>template <typename It, typename UInt>
>inline It format_decimal(It out, UInt value, unsigned num_digits) {
> return format_decimal(out, value, num_digits, no_thousands_sep());
>}
>
>template <unsigned BASE_BITS, typename Char, typename UInt>
>inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits,
> bool upper = false) {
> buffer += num_digits;
> Char *end = buffer;
> do {
> const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
> unsigned digit = (value & ((1 << BASE_BITS) - 1));
> *--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
> } while ((value >>= BASE_BITS) != 0);
> return end;
>}
>
>template <unsigned BASE_BITS, typename It, typename UInt>
>inline It format_uint(It out, UInt value, unsigned num_digits,
> bool upper = false) {
>
>
> char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 2];
> format_uint<BASE_BITS>(buffer, value, num_digits, upper);
> return std::copy_n(buffer, num_digits, out);
>}
># 1190 "/usr/local/include/fmt/format.h" 3
>template <typename T = void>
>struct null {};
>}
>
>struct monostate {};
># 1203 "/usr/local/include/fmt/format.h" 3
>template <typename Visitor, typename Context>
>constexpr typename internal::result_of<Visitor(int)>::type
> visit(Visitor &&vis, basic_format_arg<Context> arg) {
> typedef typename Context::char_type char_type;
> switch (arg.type_) {
> case internal::none_type:
> break;
> case internal::named_arg_type:
> (static_cast <bool> ((false) && "invalid argument type") ? void (0) : __assert_fail ("(false) && \"invalid argument type\"", "/usr/local/include/fmt/format.h", 1211, __extension__ __PRETTY_FUNCTION__));
> break;
> case internal::int_type:
> return vis(arg.value_.int_value);
> case internal::uint_type:
> return vis(arg.value_.uint_value);
> case internal::long_long_type:
> return vis(arg.value_.long_long_value);
> case internal::ulong_long_type:
> return vis(arg.value_.ulong_long_value);
> case internal::bool_type:
> return vis(arg.value_.int_value != 0);
> case internal::char_type:
> return vis(static_cast<char_type>(arg.value_.int_value));
> case internal::double_type:
> return vis(arg.value_.double_value);
> case internal::long_double_type:
> return vis(arg.value_.long_double_value);
> case internal::cstring_type:
> return vis(arg.value_.string.value);
> case internal::string_type:
> return vis(basic_string_view<char_type>(
> arg.value_.string.value, arg.value_.string.size));
> case internal::pointer_type:
> return vis(arg.value_.pointer);
> case internal::custom_type:
> return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
> }
> return vis(monostate());
>}
>
>enum alignment {
> ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
>};
>
>
>enum {SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8};
>
>enum format_spec_tag {fill_tag, align_tag, width_tag, type_tag};
>
>
>template <typename T, format_spec_tag>
>class format_spec {
> private:
> T value_;
>
> public:
> typedef T value_type;
>
> explicit format_spec(T value) : value_(value) {}
>
> T value() const { return value_; }
>};
>
>
>
>template <typename Char>
>class fill_spec : public format_spec<Char, fill_tag> {
> public:
> explicit fill_spec(Char value) : format_spec<Char, fill_tag>(value) {}
>};
>
>typedef format_spec<unsigned, width_tag> width_spec;
>typedef format_spec<char, type_tag> type_spec;
>
>
>struct empty_spec {};
>
>
>struct align_spec : empty_spec {
> unsigned width_;
>
>
> wchar_t fill_;
> alignment align_;
>
> constexpr align_spec(
> unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT)
> : width_(width), fill_(fill), align_(align) {}
>
> constexpr unsigned width() const { return width_; }
> constexpr wchar_t fill() const { return fill_; }
> constexpr alignment align() const { return align_; }
>
> int precision() const { return -1; }
>};
>
>
>template <typename Char>
>class basic_format_specs : public align_spec {
> private:
> template <typename FillChar>
> typename std::enable_if<std::is_same<FillChar, Char>::value ||
> std::is_same<FillChar, char>::value, void>::type
> set(fill_spec<FillChar> fill) {
> fill_ = fill.value();
> }
>
> void set(width_spec width) {
> width_ = width.value();
> }
>
> void set(type_spec type) {
> type_ = type.value();
> }
>
> template <typename Spec, typename... Specs>
> void set(Spec spec, Specs... tail) {
> set(spec);
> set(tail...);
> }
>
> public:
> unsigned flags_;
> int precision_;
> Char type_;
>
> constexpr basic_format_specs(
> unsigned width = 0, char type = 0, wchar_t fill = ' ')
> : align_spec(width, fill), flags_(0), precision_(-1), type_(type) {}
>
> template <typename... FormatSpecs>
> explicit basic_format_specs(FormatSpecs... specs)
> : align_spec(0, ' '), flags_(0), precision_(-1), type_(0) {
> set(specs...);
> }
>
> constexpr bool flag(unsigned f) const { return (flags_ & f) != 0; }
> constexpr int precision() const { return precision_; }
> constexpr Char type() const { return type_; }
>};
>
>typedef basic_format_specs<char> format_specs;
>
>template <typename Char, typename ErrorHandler>
>constexpr unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id() {
> if (next_arg_id_ >= 0)
> return internal::to_unsigned(next_arg_id_++);
> on_error("cannot switch from manual to automatic argument indexing");
> return 0;
>}
>
>struct format_string {};
>
>namespace internal {
>
>template <typename Char, typename Handler>
>constexpr void handle_int_type_spec(Char spec, Handler &&handler) {
> switch (spec) {
> case 0: case 'd':
> handler.on_dec();
> break;
> case 'x': case 'X':
> handler.on_hex();
> break;
> case 'b': case 'B':
> handler.on_bin();
> break;
> case 'o':
> handler.on_oct();
> break;
> case 'n':
> handler.on_num();
> break;
> default:
> handler.on_error();
> }
>}
>
>template <typename Char, typename Handler>
>constexpr void handle_float_type_spec(Char spec, Handler &&handler) {
> switch (spec) {
> case 0: case 'g': case 'G':
> handler.on_general();
> break;
> case 'e': case 'E':
> handler.on_exp();
> break;
> case 'f': case 'F':
> handler.on_fixed();
> break;
> case 'a': case 'A':
> handler.on_hex();
> break;
> default:
> handler.on_error();
> break;
> }
>}
>
>template <typename Char, typename Handler>
>constexpr void handle_char_specs(
> const basic_format_specs<Char> &specs, Handler &&handler) {
> if (specs.type() && specs.type() != 'c') {
> handler.on_int();
> return;
> }
> if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0)
> handler.on_error("invalid format specifier for char");
> handler.on_char();
>}
>
>template <typename Char, typename Handler>
>constexpr void handle_cstring_type_spec(Char spec, Handler &&handler) {
> if (spec == 0 || spec == 's')
> handler.on_string();
> else if (spec == 'p')
> handler.on_pointer();
> else
> handler.on_error("invalid type specifier");
>}
>
>template <typename Char, typename ErrorHandler>
>constexpr void check_string_type_spec(Char spec, ErrorHandler &&eh) {
> if (spec != 0 && spec != 's')
> eh.on_error("invalid type specifier");
>}
>
>template <typename Char, typename ErrorHandler>
>constexpr void check_pointer_type_spec(Char spec, ErrorHandler &&eh) {
> if (spec != 0 && spec != 'p')
> eh.on_error("invalid type specifier");
>}
>
>template <typename ErrorHandler>
>class int_type_checker : private ErrorHandler {
> public:
> constexpr explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
>
> constexpr void on_dec() {}
> constexpr void on_hex() {}
> constexpr void on_bin() {}
> constexpr void on_oct() {}
> constexpr void on_num() {}
>
> constexpr void on_error() {
> ErrorHandler::on_error("invalid type specifier");
> }
>};
>
>template <typename ErrorHandler>
>class float_type_checker : private ErrorHandler {
> public:
> constexpr explicit float_type_checker(ErrorHandler eh)
> : ErrorHandler(eh) {}
>
> constexpr void on_general() {}
> constexpr void on_exp() {}
> constexpr void on_fixed() {}
> constexpr void on_hex() {}
>
> constexpr void on_error() {
> ErrorHandler::on_error("invalid type specifier");
> }
>};
>
>template <typename ErrorHandler, typename CharType>
>class char_specs_checker : public ErrorHandler {
> private:
> CharType type_;
>
> public:
> constexpr char_specs_checker(CharType type, ErrorHandler eh)
> : ErrorHandler(eh), type_(type) {}
>
> constexpr void on_int() {
> handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
> }
> constexpr void on_char() {}
>};
>
>template <typename ErrorHandler>
>class cstring_type_checker : public ErrorHandler {
> public:
> constexpr explicit cstring_type_checker(ErrorHandler eh)
> : ErrorHandler(eh) {}
>
> constexpr void on_string() {}
> constexpr void on_pointer() {}
>};
>
>template <typename Context>
>void arg_map<Context>::init(const basic_format_args<Context> &args) {
> if (map_)
> return;
> map_ = new entry[args.max_size()];
> bool use_values = args.type(max_packed_args - 1) == internal::none_type;
> if (use_values) {
> for (unsigned i = 0; ; ++i) {
> internal::type arg_type = args.type(i);
> switch (arg_type) {
> case internal::none_type:
> return;
> case internal::named_arg_type:
> push_back(args.values_[i]);
> break;
> default:
> break;
> }
> }
> return;
> }
> for (unsigned i = 0; ; ++i) {
> switch (args.args_[i].type_) {
> case internal::none_type:
> return;
> case internal::named_arg_type:
> push_back(args.args_[i].value_);
> break;
> default:
> break;
> }
> }
>}
>
>template <typename Range>
>class arg_formatter_base {
> public:
> typedef typename Range::value_type char_type;
> typedef decltype(internal::declval<Range>().begin()) iterator;
> typedef basic_format_specs<char_type> format_specs;
>
> private:
> typedef basic_writer<Range> writer_type;
> writer_type writer_;
> format_specs &specs_;
>
> arg_formatter_base(const arg_formatter_base &) = delete; void operator=(const arg_formatter_base &) = delete;
>
> struct char_writer {
> char_type value;
> template <typename It>
> void operator()(It &&it) const { *it++ = value; }
> };
>
> void write_char(char_type value) {
> writer_.write_padded(1, specs_, char_writer{value});
> }
>
> void write_pointer(const void *p) {
> format_specs specs = specs_;
> specs.flags_ = HASH_FLAG;
> specs.type_ = 'x';
> writer_.write_int(reinterpret_cast<uintptr_t>(p), specs);
> }
>
> protected:
> writer_type &writer() { return writer_; }
> format_specs &spec() { return specs_; }
> iterator out() { return writer_.out(); }
>
> void write(bool value) {
> writer_.write_str(string_view(value ? "true" : "false"), specs_);
> }
>
> void write(const char_type *value) {
> if (!value)
> throw format_error("string pointer is null");
> auto length = std::char_traits<char_type>::length(value);
> writer_.write_str(basic_string_view<char_type>(value, length), specs_);
> }
>
> public:
> arg_formatter_base(Range r, format_specs &s): writer_(r), specs_(s) {}
>
> iterator operator()(monostate) {
> (static_cast <bool> ((false) && "invalid argument type") ? void (0) : __assert_fail ("(false) && \"invalid argument type\"", "/usr/local/include/fmt/format.h", 1577, __extension__ __PRETTY_FUNCTION__));
> return out();
> }
>
> template <typename T>
> typename std::enable_if<std::is_integral<T>::value, iterator>::type
> operator()(T value) {
> writer_.write_int(value, specs_);
> return out();
> }
>
> template <typename T>
> typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
> operator()(T value) {
> writer_.write_double(value, specs_);
> return out();
> }
>
> iterator operator()(bool value) {
> if (specs_.type_)
> return (*this)(value ? 1 : 0);
> write(value);
> return out();
> }
>
> struct char_spec_handler : internal::error_handler {
> arg_formatter_base &formatter;
> char_type value;
>
> char_spec_handler(arg_formatter_base& f, char_type val)
> : formatter(f), value(val) {}
>
> void on_int() { formatter.writer_.write_int(value, formatter.specs_); }
> void on_char() { formatter.write_char(value); }
> };
>
> iterator operator()(char_type value) {
> internal::handle_char_specs(specs_, char_spec_handler(*this, value));
> return out();
> }
>
> struct cstring_spec_handler : internal::error_handler {
> arg_formatter_base &formatter;
> const char_type *value;
>
> cstring_spec_handler(arg_formatter_base &f, const char_type *val)
> : formatter(f), value(val) {}
>
> void on_string() { formatter.write(value); }
> void on_pointer() { formatter.write_pointer(value); }
> };
>
> iterator operator()(const char_type *value) {
> internal::handle_cstring_type_spec(
> specs_.type_, cstring_spec_handler(*this, value));
> return out();
> }
>
> iterator operator()(basic_string_view<char_type> value) {
> internal::check_string_type_spec(specs_.type_, internal::error_handler());
> writer_.write_str(value, specs_);
> return out();
> }
>
> iterator operator()(const void *value) {
> check_pointer_type_spec(specs_.type_, internal::error_handler());
> write_pointer(value);
> return out();
> }
>};
>
>template <typename S>
>struct is_format_string:
> std::integral_constant<bool, std::is_base_of<format_string, S>::value> {};
>
>template <typename Char>
>constexpr bool is_name_start(Char c) {
> return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
>}
>
>
>
>
>template <typename Iterator, typename ErrorHandler>
>constexpr unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
> (static_cast <bool> ('0' <= *it && *it <= '9') ? void (0) : __assert_fail ("'0' <= *it && *it <= '9'", "/usr/local/include/fmt/format.h", 1662, __extension__ __PRETTY_FUNCTION__));
> unsigned value = 0;
>
> unsigned max_int = (std::numeric_limits<int>::max)();
> unsigned big = max_int / 10;
> do {
>
> if (value > big) {
> value = max_int + 1;
> break;
> }
> value = value * 10 + (*it - '0');
>
> auto next = it;
> ++next;
> it = next;
> } while ('0' <= *it && *it <= '9');
> if (value > max_int)
> eh.on_error("number is too big");
> return value;
>}
>
>template <typename Char, typename Context>
>class custom_formatter: public function<bool> {
> private:
> Context &ctx_;
>
> public:
> explicit custom_formatter(Context &ctx): ctx_(ctx) {}
>
> bool operator()(typename basic_format_arg<Context>::handle h) const {
> h.format(ctx_);
> return true;
> }
>
> template <typename T>
> bool operator()(T) const { return false; }
>};
>
>template <typename T>
>struct is_integer {
> enum {
> value = std::is_integral<T>::value && !std::is_same<T, bool>::value &&
> !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value
> };
>};
>
>template <typename ErrorHandler>
>class width_checker: public function<unsigned long long> {
> public:
> explicit constexpr width_checker(ErrorHandler &eh) : handler_(eh) {}
>
> template <typename T>
> constexpr
> typename std::enable_if<
> is_integer<T>::value, unsigned long long>::type operator()(T value) {
> if (is_negative(value))
> handler_.on_error("negative width");
> return value;
> }
>
> template <typename T>
> constexpr typename std::enable_if<
> !is_integer<T>::value, unsigned long long>::type operator()(T) {
> handler_.on_error("width is not integer");
> return 0;
> }
>
> private:
> ErrorHandler &handler_;
>};
>
>template <typename ErrorHandler>
>class precision_checker: public function<unsigned long long> {
> public:
> explicit constexpr precision_checker(ErrorHandler &eh) : handler_(eh) {}
>
> template <typename T>
> constexpr typename std::enable_if<
> is_integer<T>::value, unsigned long long>::type operator()(T value) {
> if (is_negative(value))
> handler_.on_error("negative precision");
> return value;
> }
>
> template <typename T>
> constexpr typename std::enable_if<
> !is_integer<T>::value, unsigned long long>::type operator()(T) {
> handler_.on_error("precision is not integer");
> return 0;
> }
>
> private:
> ErrorHandler &handler_;
>};
>
>
>template <typename Char>
>class specs_setter {
> public:
> explicit constexpr specs_setter(basic_format_specs<Char> &specs):
> specs_(specs) {}
>
> constexpr specs_setter(const specs_setter &other) : specs_(other.specs_) {}
>
> constexpr void on_align(alignment align) { specs_.align_ = align; }
> constexpr void on_fill(Char fill) { specs_.fill_ = fill; }
> constexpr void on_plus() { specs_.flags_ |= SIGN_FLAG | PLUS_FLAG; }
> constexpr void on_minus() { specs_.flags_ |= MINUS_FLAG; }
> constexpr void on_space() { specs_.flags_ |= SIGN_FLAG; }
> constexpr void on_hash() { specs_.flags_ |= HASH_FLAG; }
>
> constexpr void on_zero() {
> specs_.align_ = ALIGN_NUMERIC;
> specs_.fill_ = '0';
> }
>
> constexpr void on_width(unsigned width) { specs_.width_ = width; }
> constexpr void on_precision(unsigned precision) {
> specs_.precision_ = precision;
> }
> constexpr void end_precision() {}
>
> constexpr void on_type(Char type) { specs_.type_ = type; }
>
> protected:
> basic_format_specs<Char> &specs_;
>};
>
>
>
>template <typename Handler>
>class specs_checker : public Handler {
> public:
> constexpr specs_checker(const Handler& handler, internal::type arg_type)
> : Handler(handler), arg_type_(arg_type) {}
>
> constexpr specs_checker(const specs_checker &other)
> : Handler(other), arg_type_(other.arg_type_) {}
>
> constexpr void on_align(alignment align) {
> if (align == ALIGN_NUMERIC)
> require_numeric_argument();
> Handler::on_align(align);
> }
>
> constexpr void on_plus() {
> check_sign();
> Handler::on_plus();
> }
>
> constexpr void on_minus() {
> check_sign();
> Handler::on_minus();
> }
>
> constexpr void on_space() {
> check_sign();
> Handler::on_space();
> }
>
> constexpr void on_hash() {
> require_numeric_argument();
> Handler::on_hash();
> }
>
> constexpr void on_zero() {
> require_numeric_argument();
> Handler::on_zero();
> }
>
> constexpr void end_precision() {
> if (is_integral(arg_type_) || arg_type_ == pointer_type)
> this->on_error("precision not allowed for this argument type");
> }
>
> private:
> constexpr void require_numeric_argument() {
> if (!is_arithmetic(arg_type_))
> this->on_error("format specifier requires numeric argument");
> }
>
> constexpr void check_sign() {
> require_numeric_argument();
> if (is_integral(arg_type_) && arg_type_ != int_type &&
> arg_type_ != long_long_type && arg_type_ != internal::char_type) {
> this->on_error("format specifier requires signed argument");
> }
> }
>
> internal::type arg_type_;
>};
>
>template <template <typename> class Handler, typename T,
> typename Context, typename ErrorHandler>
>constexpr void set_dynamic_spec(
> T &value, basic_format_arg<Context> arg, ErrorHandler eh) {
> unsigned long long big_value = visit(Handler<ErrorHandler>(eh), arg);
> if (big_value > (std::numeric_limits<int>::max)())
> eh.on_error("number is too big");
> value = static_cast<int>(big_value);
>}
>
>struct auto_id {};
>
>
>template <typename Context>
>class specs_handler: public specs_setter<typename Context::char_type> {
> public:
> typedef typename Context::char_type char_type;
>
> constexpr specs_handler(basic_format_specs<char_type> &specs, Context &ctx)
> : specs_setter<char_type>(specs), context_(ctx) {}
>
> template <typename Id>
> constexpr void on_dynamic_width(Id arg_id) {
> set_dynamic_spec<width_checker>(
> this->specs_.width_, get_arg(arg_id), context_.error_handler());
> }
>
> template <typename Id>
> constexpr void on_dynamic_precision(Id arg_id) {
> set_dynamic_spec<precision_checker>(
> this->specs_.precision_, get_arg(arg_id), context_.error_handler());
> }
>
> void on_error(const char *message) {
> context_.on_error(message);
> }
>
> private:
> constexpr basic_format_arg<Context> get_arg(auto_id) {
> return context_.next_arg();
> }
>
> template <typename Id>
> constexpr basic_format_arg<Context> get_arg(Id arg_id) {
> context_.parse_context().check_arg_id(arg_id);
> return context_.get_arg(arg_id);
> }
>
> Context &context_;
>};
>
>
>template <typename Char>
>struct arg_ref {
> enum Kind { NONE, INDEX, NAME };
>
> constexpr arg_ref() : kind(NONE), index(0) {}
> constexpr explicit arg_ref(unsigned index) : kind(INDEX), index(index) {}
> explicit arg_ref(basic_string_view<Char> name) : kind(NAME), name(name) {}
>
> constexpr arg_ref &operator=(unsigned idx) {
> kind = INDEX;
> index = idx;
> return *this;
> }
>
> Kind kind;
> union {
> unsigned index;
> basic_string_view<Char> name;
> };
>};
>
>
>
>
>template <typename Char>
>struct dynamic_format_specs : basic_format_specs<Char> {
> arg_ref<Char> width_ref;
> arg_ref<Char> precision_ref;
>};
>
>
>
>template <typename ParseContext>
>class dynamic_specs_handler :
> public specs_setter<typename ParseContext::char_type> {
> public:
> typedef typename ParseContext::char_type char_type;
>
> constexpr dynamic_specs_handler(
> dynamic_format_specs<char_type> &specs, ParseContext &ctx)
> : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
>
> constexpr dynamic_specs_handler(const dynamic_specs_handler &other)
> : specs_setter<char_type>(other),
> specs_(other.specs_), context_(other.context_) {}
>
> template <typename Id>
> constexpr void on_dynamic_width(Id arg_id) {
> specs_.width_ref = make_arg_ref(arg_id);
> }
>
> template <typename Id>
> constexpr void on_dynamic_precision(Id arg_id) {
> specs_.precision_ref = make_arg_ref(arg_id);
> }
>
> constexpr void on_error(const char *message) {
> context_.on_error(message);
> }
>
> private:
> typedef arg_ref<char_type> arg_ref_type;
>
> template <typename Id>
> constexpr arg_ref_type make_arg_ref(Id arg_id) {
> context_.check_arg_id(arg_id);
> return arg_ref_type(arg_id);
> }
>
> constexpr arg_ref_type make_arg_ref(auto_id) {
> return arg_ref_type(context_.next_arg_id());
> }
>
> dynamic_format_specs<char_type> &specs_;
> ParseContext &context_;
>};
>
>template <typename Iterator, typename IDHandler>
>constexpr Iterator parse_arg_id(Iterator it, IDHandler &&handler) {
> typedef typename std::iterator_traits<Iterator>::value_type char_type;
> char_type c = *it;
> if (c == '}' || c == ':') {
> handler();
> return it;
> }
> if (c >= '0' && c <= '9') {
> unsigned index = parse_nonnegative_int(it, handler);
> if (*it != '}' && *it != ':') {
> handler.on_error("invalid format string");
> return it;
> }
> handler(index);
> return it;
> }
> if (!is_name_start(c)) {
> handler.on_error("invalid format string");
> return it;
> }
> auto start = it;
> do {
> c = *++it;
> } while (is_name_start(c) || ('0' <= c && c <= '9'));
> handler(basic_string_view<char_type>(pointer_from(start), it - start));
> return it;
>}
>
>
>template <typename SpecHandler, typename Char>
>struct width_adapter {
> explicit constexpr width_adapter(SpecHandler &h) : handler(h) {}
>
> constexpr void operator()() { handler.on_dynamic_width(auto_id()); }
> constexpr void operator()(unsigned id) { handler.on_dynamic_width(id); }
> constexpr void operator()(basic_string_view<Char> id) {
> handler.on_dynamic_width(id);
> }
>
> constexpr void on_error(const char *message) {
> handler.on_error(message);
> }
>
> SpecHandler &handler;
>};
>
>
>template <typename SpecHandler, typename Char>
>struct precision_adapter {
> explicit constexpr precision_adapter(SpecHandler &h) : handler(h) {}
>
> constexpr void operator()() { handler.on_dynamic_precision(auto_id()); }
> constexpr void operator()(unsigned id) {
> handler.on_dynamic_precision(id);
> }
> constexpr void operator()(basic_string_view<Char> id) {
> handler.on_dynamic_precision(id);
> }
>
> constexpr void on_error(const char *message) { handler.on_error(message); }
>
> SpecHandler &handler;
>};
>
>
>
>
>
>
>template <typename Iterator, typename SpecHandler>
>constexpr Iterator parse_format_specs(Iterator it, SpecHandler &&handler) {
> typedef typename std::iterator_traits<Iterator>::value_type char_type;
> char_type c = *it;
> if (c == '}' || !c)
> return it;
>
>
> alignment align = ALIGN_DEFAULT;
> int i = 1;
> do {
> auto p = it + i;
> switch (*p) {
> case '<':
> align = ALIGN_LEFT;
> break;
> case '>':
> align = ALIGN_RIGHT;
> break;
> case '=':
> align = ALIGN_NUMERIC;
> break;
> case '^':
> align = ALIGN_CENTER;
> break;
> }
> if (align != ALIGN_DEFAULT) {
> if (p != it) {
> if (c == '{') {
> handler.on_error("invalid fill character '{'");
> return it;
> }
> it += 2;
> handler.on_fill(c);
> } else ++it;
> handler.on_align(align);
> break;
> }
> } while (--i >= 0);
>
>
> switch (*it) {
> case '+':
> handler.on_plus();
> ++it;
> break;
> case '-':
> handler.on_minus();
> ++it;
> break;
> case ' ':
> handler.on_space();
> ++it;
> break;
> }
>
> if (*it == '#') {
> handler.on_hash();
> ++it;
> }
>
>
> if (*it == '0') {
> handler.on_zero();
> ++it;
> }
>
>
> if ('0' <= *it && *it <= '9') {
> handler.on_width(parse_nonnegative_int(it, handler));
> } else if (*it == '{') {
> it = parse_arg_id(it + 1, width_adapter<SpecHandler, char_type>(handler));
> if (*it++ != '}') {
> handler.on_error("invalid format string");
> return it;
> }
> }
>
>
> if (*it == '.') {
> ++it;
> if ('0' <= *it && *it <= '9') {
> handler.on_precision(parse_nonnegative_int(it, handler));
> } else if (*it == '{') {
> it = parse_arg_id(
> it + 1, precision_adapter<SpecHandler, char_type>(handler));
> if (*it++ != '}') {
> handler.on_error("invalid format string");
> return it;
> }
> } else {
> handler.on_error("missing precision specifier");
> return it;
> }
> handler.end_precision();
> }
>
>
> if (*it != '}' && *it)
> handler.on_type(*it++);
> return it;
>}
>
>template <typename Handler, typename Char>
>struct id_adapter {
> constexpr explicit id_adapter(Handler &h): handler(h) {}
>
> constexpr void operator()() { handler.on_arg_id(); }
> constexpr void operator()(unsigned id) { handler.on_arg_id(id); }
> constexpr void operator()(basic_string_view<Char> id) {
> handler.on_arg_id(id);
> }
>
> constexpr void on_error(const char *message) {
> handler.on_error(message);
> }
>
> Handler &handler;
>};
>
>template <typename Iterator, typename Handler>
>constexpr void parse_format_string(Iterator it, Handler &&handler) {
> typedef typename std::iterator_traits<Iterator>::value_type char_type;
> auto start = it;
> while (*it) {
> char_type ch = *it++;
> if (ch != '{' && ch != '}') continue;
> if (*it == ch) {
> handler.on_text(start, it);
> start = ++it;
> continue;
> }
> if (ch == '}') {
> handler.on_error("unmatched '}' in format string");
> return;
> }
> handler.on_text(start, it - 1);
>
> it = parse_arg_id(it, id_adapter<Handler, char_type>(handler));
> if (*it == '}') {
> handler.on_replacement_field(it);
> } else if (*it == ':') {
> ++it;
> it = handler.on_format_specs(it);
> if (*it != '}') {
> handler.on_error("unknown format specifier");
> return;
> }
> } else {
> handler.on_error("missing '}' in format string");
> return;
> }
>
> start = ++it;
> }
> handler.on_text(start, it);
>}
>
>template <typename T, typename ParseContext>
>constexpr const typename ParseContext::char_type *
> parse_format_specs(ParseContext &ctx) {
>
> formatter<T, typename ParseContext::char_type> f{};
> return f.parse(ctx);
>}
>
>template <typename Char, typename ErrorHandler, typename... Args>
>class format_string_checker {
> public:
> explicit constexpr format_string_checker(
> basic_string_view<Char> format_str, ErrorHandler eh)
> : arg_id_(-1), context_(format_str, eh),
> parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
>
> constexpr void on_text(const Char *, const Char *) {}
>
> constexpr void on_arg_id() {
> arg_id_ = context_.next_arg_id();
> check_arg_id();
> }
> constexpr void on_arg_id(unsigned id) {
> arg_id_ = id;
> context_.check_arg_id(id);
> check_arg_id();
> }
> constexpr void on_arg_id(basic_string_view<Char>) {}
>
> constexpr void on_replacement_field(const Char *) {}
>
> constexpr const Char *on_format_specs(const Char *s) {
> context_.advance_to(s);
> return to_unsigned(arg_id_) < NUM_ARGS ?
> parse_funcs_[arg_id_](context_) : s;
> }
>
> constexpr void on_error(const char *message) {
> context_.on_error(message);
> }
>
> private:
> typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
> enum { NUM_ARGS = sizeof...(Args) };
>
> constexpr void check_arg_id() {
> if (internal::to_unsigned(arg_id_) >= NUM_ARGS)
> context_.on_error("argument index out of range");
> }
>
>
> typedef const Char *(*parse_func)(parse_context_type &);
>
> int arg_id_;
> parse_context_type context_;
> parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
>};
>
>template <typename Char, typename ErrorHandler, typename... Args>
>constexpr bool check_format_string(
> basic_string_view<Char> s, ErrorHandler eh = ErrorHandler()) {
> format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
> parse_format_string(s.begin(), checker);
> return true;
>}
>
>template <typename... Args, typename String>
>void check_format_string(String format_str) {
> constexpr bool invalid_format =
> internal::check_format_string<char, internal::error_handler, Args...>(
> string_view(format_str.data(), format_str.size()));
> (void)invalid_format;
>}
>
>
>
>
>template <typename Context, typename T>
>struct format_type :
> std::integral_constant<bool, get_type<Context, T>::value != custom_type> {};
>
>
>template <typename T, typename Enable = void>
>struct format_enum : std::integral_constant<bool, std::is_enum<T>::value> {};
>
>template <template <typename> class Handler, typename Spec, typename Context>
>void handle_dynamic_spec(
> Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx) {
> typedef typename Context::char_type char_type;
> switch (ref.kind) {
> case arg_ref<char_type>::NONE:
> break;
> case arg_ref<char_type>::INDEX:
> internal::set_dynamic_spec<Handler>(
> value, ctx.get_arg(ref.index), ctx.error_handler());
> break;
> case arg_ref<char_type>::NAME:
> internal::set_dynamic_spec<Handler>(
> value, ctx.get_arg(ref.name), ctx.error_handler());
> break;
> }
>}
>}
>
>
>template <typename Range>
>class arg_formatter:
> public internal::function<
> typename internal::arg_formatter_base<Range>::iterator>,
> public internal::arg_formatter_base<Range> {
> private:
> typedef typename Range::value_type char_type;
> typedef internal::arg_formatter_base<Range> base;
> typedef basic_format_context<typename base::iterator, char_type> context_type;
>
> context_type &ctx_;
>
> public:
> typedef Range range;
> typedef typename base::iterator iterator;
> typedef typename base::format_specs format_specs;
># 2341 "/usr/local/include/fmt/format.h" 3
> arg_formatter(context_type &ctx, format_specs &spec)
> : base(Range(ctx.out()), spec), ctx_(ctx) {}
>
> using base::operator();
>
>
> iterator operator()(typename basic_format_arg<context_type>::handle handle) {
> handle.format(ctx_);
> return this->out();
> }
>};
>
>
>
>
>
>class system_error : public std::runtime_error {
> private:
> void init(int err_code, string_view format_str, format_args args);
>
> protected:
> int error_code_;
>
> system_error() : std::runtime_error("") {}
>
> public:
># 2385 "/usr/local/include/fmt/format.h" 3
> template <typename... Args>
> system_error(int error_code, string_view message, const Args & ... args)
> : std::runtime_error("") {
> init(error_code, message, make_format_args(args...));
> }
>
> int error_code() const { return error_code_; }
>};
># 2410 "/usr/local/include/fmt/format.h" 3
> void format_system_error(internal::buffer &out, int error_code,
> fmt::string_view message) noexcept;
>
>
>
>
>
>template <typename Range>
>class basic_writer {
> public:
> typedef typename Range::value_type char_type;
> typedef decltype(internal::declval<Range>().begin()) iterator;
> typedef basic_format_specs<char_type> format_specs;
>
> private:
>
> iterator out_;
>
> std::unique_ptr<locale_provider> locale_;
>
> basic_writer(const basic_writer &) = delete; void operator=(const basic_writer &) = delete;
>
> iterator out() const { return out_; }
>
>
>
> auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
> return internal::reserve(out_, n);
> }
>
>
>
>
> template <typename F>
> void write_padded(std::size_t size, const align_spec &spec, F f);
>
> template <typename F>
> struct padded_int_writer {
> string_view prefix;
> char_type fill;
> std::size_t padding;
> F f;
>
> template <typename It>
> void operator()(It &&it) const {
> if (prefix.size() != 0)
> it = std::copy_n(prefix.data(), prefix.size(), it);
> it = std::fill_n(it, padding, fill);
> f(it);
> }
> };
>
>
>
>
> template <typename Spec, typename F>
> void write_int(unsigned num_digits, string_view prefix,
> const Spec &spec, F f) {
> std::size_t size = prefix.size() + num_digits;
> char_type fill = static_cast<char_type>(spec.fill());
> std::size_t padding = 0;
> if (spec.align() == ALIGN_NUMERIC) {
> if (spec.width() > size) {
> padding = spec.width() - size;
> size = spec.width();
> }
> } else if (spec.precision() > static_cast<int>(num_digits)) {
> size = prefix.size() + spec.precision();
> padding = spec.precision() - num_digits;
> fill = '0';
> }
> align_spec as = spec;
> if (spec.align() == ALIGN_DEFAULT)
> as.align_ = ALIGN_RIGHT;
> write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
> }
>
>
> template <typename Int>
> void write_decimal(Int value) {
> typedef typename internal::int_traits<Int>::main_type main_type;
> main_type abs_value = static_cast<main_type>(value);
> bool is_negative = internal::is_negative(value);
> if (is_negative)
> abs_value = 0 - abs_value;
> unsigned num_digits = internal::count_digits(abs_value);
> auto &&it = reserve((is_negative ? 1 : 0) + num_digits);
> if (is_negative)
> *it++ = '-';
> internal::format_decimal(it, abs_value, num_digits);
> }
>
>
> template <typename Int, typename Spec>
> struct int_writer {
> typedef typename internal::int_traits<Int>::main_type unsigned_type;
>
> basic_writer<Range> &writer;
> const Spec &spec;
> unsigned_type abs_value;
> char prefix[4];
> unsigned prefix_size;
>
> string_view get_prefix() const { return string_view(prefix, prefix_size); }
>
>
> template <unsigned BITS>
> unsigned count_digits() const {
> unsigned_type n = abs_value;
> unsigned num_digits = 0;
> do {
> ++num_digits;
> } while ((n >>= BITS) != 0);
> return num_digits;
> }
>
> int_writer(basic_writer<Range> &w, Int value, const Spec &s)
> : writer(w), spec(s), abs_value(static_cast<unsigned_type>(value)),
> prefix_size(0) {
> if (internal::is_negative(value)) {
> prefix[0] = '-';
> ++prefix_size;
> abs_value = 0 - abs_value;
> } else if (spec.flag(SIGN_FLAG)) {
> prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
> ++prefix_size;
> }
> }
>
> struct dec_writer {
> unsigned_type abs_value;
> unsigned num_digits;
>
> template <typename It>
> void operator()(It &&it) const {
> it = internal::format_decimal(it, abs_value, num_digits);
> }
> };
>
> void on_dec() {
> unsigned num_digits = internal::count_digits(abs_value);
> writer.write_int(num_digits, get_prefix(), spec,
> dec_writer{abs_value, num_digits});
> }
>
> struct hex_writer {
> int_writer &self;
> unsigned num_digits;
>
> template <typename It>
> void operator()(It &&it) const {
> it = internal::format_uint<4>(it, self.abs_value, num_digits,
> self.spec.type() != 'x');
> }
> };
>
> void on_hex() {
> if (spec.flag(HASH_FLAG)) {
> prefix[prefix_size++] = '0';
> prefix[prefix_size++] = static_cast<char>(spec.type());
> }
> unsigned num_digits = count_digits<4>();
> writer.write_int(num_digits, get_prefix(), spec,
> hex_writer{*this, num_digits});
> }
>
> template <int BITS>
> struct bin_writer {
> unsigned_type abs_value;
> unsigned num_digits;
>
> template <typename It>
> void operator()(It &&it) const {
> it = internal::format_uint<BITS>(it, abs_value, num_digits);
> }
> };
>
> void on_bin() {
> if (spec.flag(HASH_FLAG)) {
> prefix[prefix_size++] = '0';
> prefix[prefix_size++] = static_cast<char>(spec.type());
> }
> unsigned num_digits = count_digits<1>();
> writer.write_int(num_digits, get_prefix(), spec,
> bin_writer<1>{abs_value, num_digits});
> }
>
> void on_oct() {
> unsigned num_digits = count_digits<3>();
> if (spec.flag(HASH_FLAG) &&
> spec.precision() <= static_cast<int>(num_digits)) {
>
>
> prefix[prefix_size++] = '0';
> }
> writer.write_int(num_digits, get_prefix(), spec,
> bin_writer<3>{abs_value, num_digits});
> }
>
> enum { SEP_SIZE = 1 };
>
> struct num_writer {
> unsigned_type abs_value;
> unsigned size;
> char_type sep;
>
> template <typename It>
> void operator()(It &&it) const {
> basic_string_view<char_type> s(&sep, SEP_SIZE);
> it = format_decimal(it, abs_value, size,
> internal::add_thousands_sep<char_type>(s));
> }
> };
>
> void on_num() {
> unsigned num_digits = internal::count_digits(abs_value);
> char_type sep = internal::thousands_sep<char_type>(writer.locale_.get());
> unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
> writer.write_int(size, get_prefix(), spec,
> num_writer{abs_value, size, sep});
> }
>
> void on_error() {
> throw format_error("invalid type specifier");
> }
> };
>
>
> template <typename T, typename Spec>
> void write_int(T value, const Spec &spec) {
> internal::handle_int_type_spec(spec.type(),
> int_writer<T, Spec>(*this, value, spec));
> }
>
> enum {INF_SIZE = 3};
>
> struct inf_or_nan_writer {
> char sign;
> const char *str;
>
> template <typename It>
> void operator()(It &&it) const {
> if (sign)
> *it++ = sign;
> it = std::copy_n(str, static_cast<std::size_t>(INF_SIZE), it);
> }
> };
>
> struct double_writer {
> size_t n;
> char sign;
> basic_memory_buffer<char_type> &buffer;
>
> template <typename It>
> void operator()(It &&it) {
> if (sign) {
> *it++ = sign;
> --n;
> }
> it = std::copy_n(buffer.begin(), n, it);
> }
> };
>
>
> template <typename T>
> void write_double(T value, const format_specs &spec);
> template <typename T>
> void write_double_sprintf(T value, const format_specs &spec,
> internal::basic_buffer<char_type>& buffer);
>
> template <typename Char>
> struct str_writer {
> const Char *s;
> std::size_t size;
>
> template <typename It>
> void operator()(It &&it) const {
> it = std::copy_n(s, size, it);
> }
> };
>
>
> template <typename Char>
> void write_str(const Char *s, std::size_t size, const align_spec &spec) {
> write_padded(size, spec, str_writer<Char>{s, size});
> }
>
> template <typename Char>
> void write_str(basic_string_view<Char> str, const format_specs &spec);
>
>
>
> void append_float_length(char_type *&format_ptr, long double) {
> *format_ptr++ = 'L';
> }
>
> template<typename T>
> void append_float_length(char_type *&, T) {}
>
> template <typename Char>
> friend class internal::arg_formatter_base;
>
> public:
>
> explicit basic_writer(Range out): out_(out.begin()) {}
>
> void write(int value) { write_decimal(value); }
> void write(long value) { write_decimal(value); }
> void write(long long value) { write_decimal(value); }
>
> void write(unsigned value) { write_decimal(value); }
> void write(unsigned long value) { write_decimal(value); }
> void write(unsigned long long value) { write_decimal(value); }
>
>
>
>
>
>
> template <typename T, typename FormatSpec, typename... FormatSpecs>
> typename std::enable_if<std::is_integral<T>::value, void>::type
> write(T value, FormatSpec spec, FormatSpecs... specs) {
> format_specs s(spec, specs...);
> s.align_ = ALIGN_RIGHT;
> write_int(value, s);
> }
>
> void write(double value) {
> write_double(value, format_specs());
> }
>
>
>
>
>
>
>
> void write(long double value) {
> write_double(value, format_specs());
> }
>
>
> void write(char value) {
> *reserve(1) = value;
> }
>
> void write(wchar_t value) {
> internal::require_wchar<char_type>();
> *reserve(1) = value;
> }
>
>
>
>
>
>
> void write(string_view value) {
> auto &&it = reserve(value.size());
> it = std::copy(value.begin(), value.end(), it);
> }
>
> void write(wstring_view value) {
> internal::require_wchar<char_type>();
> auto &&it = reserve(value.size());
> it = std::uninitialized_copy(value.begin(), value.end(), it);
> }
>
> template <typename... FormatSpecs>
> void write(basic_string_view<char_type> str, FormatSpecs... specs) {
> write_str(str, format_specs(specs...));
> }
>
> template <typename T>
> typename std::enable_if<std::is_same<T, void>::value>::type write(const T* p) {
> format_specs specs;
> specs.flags_ = HASH_FLAG;
> specs.type_ = 'x';
> write_int(reinterpret_cast<uintptr_t>(p), specs);
> }
>};
>
>template <typename Range>
>template <typename F>
>void basic_writer<Range>::write_padded(
> std::size_t size, const align_spec &spec, F f) {
> unsigned width = spec.width();
> if (width <= size)
> return f(reserve(size));
> auto &&it = reserve(width);
> char_type fill = static_cast<char_type>(spec.fill());
> std::size_t padding = width - size;
> if (spec.align() == ALIGN_RIGHT) {
> it = std::fill_n(it, padding, fill);
> f(it);
> } else if (spec.align() == ALIGN_CENTER) {
> std::size_t left_padding = padding / 2;
> it = std::fill_n(it, left_padding, fill);
> f(it);
> it = std::fill_n(it, padding - left_padding, fill);
> } else {
> f(it);
> it = std::fill_n(it, padding, fill);
> }
>}
>
>template <typename Range>
>template <typename Char>
>void basic_writer<Range>::write_str(
> basic_string_view<Char> s, const format_specs &spec) {
> const Char *data = s.data();
> std::size_t size = s.size();
> std::size_t precision = static_cast<std::size_t>(spec.precision_);
> if (spec.precision_ >= 0 && precision < size)
> size = precision;
> write_str(data, size, spec);
>}
>
>template <typename Char>
>struct float_spec_handler {
> Char type;
> bool upper;
>
> explicit float_spec_handler(Char t) : type(t), upper(false) {}
>
> void on_general() {
> if (type == 'G')
> upper = true;
> else
> type = 'g';
> }
>
> void on_exp() {
> if (type == 'E')
> upper = true;
> }
>
> void on_fixed() {
> if (type == 'F') {
> upper = true;
>
>
>
>
> }
> }
>
> void on_hex() {
> if (type == 'A')
> upper = true;
> }
>
> void on_error() {
> throw format_error("invalid type specifier");
> }
>};
>
>template <typename Range>
>template <typename T>
>void basic_writer<Range>::write_double(T value, const format_specs &spec) {
>
> float_spec_handler<char_type> handler(spec.type());
> internal::handle_float_type_spec(spec.type(), handler);
>
> char sign = 0;
>
>
> if (internal::fputil::isnegative(static_cast<double>(value))) {
> sign = '-';
> value = -value;
> } else if (spec.flag(SIGN_FLAG)) {
> sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
> }
>
> struct write_inf_or_nan_t {
> basic_writer &writer;
> format_specs spec;
> char sign;
> void operator()(const char *str) const {
> writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec,
> inf_or_nan_writer{sign, str});
> }
> } write_inf_or_nan = {*this, spec, sign};
>
>
>
> if (internal::fputil::isnotanumber(value))
> return write_inf_or_nan(handler.upper ? "NAN" : "nan");
> if (internal::fputil::isinfinity(value))
> return write_inf_or_nan(handler.upper ? "INF" : "inf");
>
> basic_memory_buffer<char_type> buffer;
> if (0 && sizeof(T) <= sizeof(double) &&
> std::numeric_limits<double>::is_iec559) {
> internal::fp fp_value(static_cast<double>(value));
> fp_value.normalize();
>
> int dec_exp = 0;
> const int min_exp = -60;
> auto dec_pow = internal::get_cached_power(
> min_exp - (fp_value.e + internal::fp::significand_size), dec_exp);
> internal::fp product = fp_value * dec_pow;
>
> internal::fp one(1ull << -product.e, product.e);
> uint64_t hi = product.f >> -one.e;
> uint64_t f = product.f & (one.f - 1);
> typedef back_insert_range<internal::basic_buffer<char_type>> range;
> basic_writer<range> w{range(buffer)};
> w.write(hi);
> size_t digits = buffer.size();
> w.write('.');
> const unsigned max_digits = 18;
> while (digits++ < max_digits) {
> f *= 10;
> w.write(static_cast<char>('0' + (f >> -one.e)));
> f &= one.f - 1;
> }
> w.write('e');
> w.write(-dec_exp);
> } else {
> format_specs normalized_spec(spec);
> normalized_spec.type_ = handler.type;
> write_double_sprintf(value, normalized_spec, buffer);
> }
> size_t n = buffer.size();
> align_spec as = spec;
> if (spec.align() == ALIGN_NUMERIC) {
> if (sign) {
> auto &&it = reserve(1);
> *it++ = sign;
> sign = 0;
> if (as.width_)
> --as.width_;
> }
> as.align_ = ALIGN_RIGHT;
> } else {
> if (spec.align() == ALIGN_DEFAULT)
> as.align_ = ALIGN_RIGHT;
> if (sign)
> ++n;
> }
> write_padded(n, as, double_writer{n, sign, buffer});
>}
>
>template <typename Range>
>template <typename T>
>void basic_writer<Range>::write_double_sprintf(
> T value, const format_specs &spec,
> internal::basic_buffer<char_type>& buffer) {
>
> (static_cast <bool> ((buffer.capacity() != 0) && "empty buffer") ? void (0) : __assert_fail ("(buffer.capacity() != 0) && \"empty buffer\"", "/usr/local/include/fmt/format.h", 2959, __extension__ __PRETTY_FUNCTION__));
>
>
> enum { MAX_FORMAT_SIZE = 10};
> char_type format[MAX_FORMAT_SIZE];
> char_type *format_ptr = format;
> *format_ptr++ = '%';
> if (spec.flag(HASH_FLAG))
> *format_ptr++ = '#';
> if (spec.precision() >= 0) {
> *format_ptr++ = '.';
> *format_ptr++ = '*';
> }
>
> append_float_length(format_ptr, value);
> *format_ptr++ = spec.type();
> *format_ptr = '\0';
>
>
> char_type *start = nullptr;
> for (;;) {
> std::size_t buffer_size = buffer.capacity();
> start = &buffer[0];
> int result = internal::char_traits<char_type>::format_float(
> start, buffer_size, format, spec.precision(), value);
> if (result >= 0) {
> unsigned n = internal::to_unsigned(result);
> if (n < buffer.capacity()) {
> buffer.resize(n);
> break;
> }
> buffer.reserve(n + 1);
> } else {
>
>
> buffer.reserve(buffer.capacity() + 1);
> }
> }
>}
>
>
>
> void report_system_error(int error_code,
> string_view message) noexcept;
># 3054 "/usr/local/include/fmt/format.h" 3
>class format_int {
> private:
>
>
> enum {BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3};
> mutable char buffer_[BUFFER_SIZE];
> char *str_;
>
>
> char *format_decimal(unsigned long long value) {
> char *ptr = buffer_ + BUFFER_SIZE - 1;
> while (value >= 100) {
>
>
>
> unsigned index = static_cast<unsigned>((value % 100) * 2);
> value /= 100;
> *--ptr = internal::data::DIGITS[index + 1];
> *--ptr = internal::data::DIGITS[index];
> }
> if (value < 10) {
> *--ptr = static_cast<char>('0' + value);
> return ptr;
> }
> unsigned index = static_cast<unsigned>(value * 2);
> *--ptr = internal::data::DIGITS[index + 1];
> *--ptr = internal::data::DIGITS[index];
> return ptr;
> }
>
> void format_signed(long long value) {
> unsigned long long abs_value = static_cast<unsigned long long>(value);
> bool negative = value < 0;
> if (negative)
> abs_value = 0 - abs_value;
> str_ = format_decimal(abs_value);
> if (negative)
> *--str_ = '-';
> }
>
> public:
> explicit format_int(int value) { format_signed(value); }
> explicit format_int(long value) { format_signed(value); }
> explicit format_int(long long value) { format_signed(value); }
> explicit format_int(unsigned value) : str_(format_decimal(value)) {}
> explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
> explicit format_int(unsigned long long value) : str_(format_decimal(value)) {}
>
>
> std::size_t size() const {
> return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
> }
>
>
>
>
>
> const char *data() const { return str_; }
>
>
>
>
>
> const char *c_str() const {
> buffer_[BUFFER_SIZE - 1] = '\0';
> return str_;
> }
>
>
>
>
>
>
> std::string str() const { return std::string(str_, size()); }
>};
>
>
>
>
>template <typename T>
>inline void format_decimal(char *&buffer, T value) {
> typedef typename internal::int_traits<T>::main_type main_type;
> main_type abs_value = static_cast<main_type>(value);
> if (internal::is_negative(value)) {
> *buffer++ = '-';
> abs_value = 0 - abs_value;
> }
> if (abs_value < 100) {
> if (abs_value < 10) {
> *buffer++ = static_cast<char>('0' + abs_value);
> return;
> }
> unsigned index = static_cast<unsigned>(abs_value * 2);
> *buffer++ = internal::data::DIGITS[index];
> *buffer++ = internal::data::DIGITS[index + 1];
> return;
> }
> unsigned num_digits = internal::count_digits(abs_value);
> internal::format_decimal(buffer, abs_value, num_digits);
> buffer += num_digits;
>}
>
>
>template <typename T, typename Char>
>struct formatter<
> T, Char,
> typename std::enable_if<internal::format_type<
> typename buffer_context<Char>::type, T>::value>::type> {
>
>
>
> template <typename ParseContext>
> constexpr typename ParseContext::iterator parse(ParseContext &ctx) {
> auto it = internal::null_terminating_iterator<Char>(ctx);
> typedef internal::dynamic_specs_handler<ParseContext> handler_type;
> auto type = internal::get_type<
> typename buffer_context<Char>::type, T>::value;
> internal::specs_checker<handler_type>
> handler(handler_type(specs_, ctx), type);
> it = parse_format_specs(it, handler);
> auto type_spec = specs_.type();
> auto eh = ctx.error_handler();
> switch (type) {
> case internal::none_type:
> case internal::named_arg_type:
> (static_cast <bool> ((false) && "invalid argument type") ? void (0) : __assert_fail ("(false) && \"invalid argument type\"", "/usr/local/include/fmt/format.h", 3179, __extension__ __PRETTY_FUNCTION__));
> break;
> case internal::int_type:
> case internal::uint_type:
> case internal::long_long_type:
> case internal::ulong_long_type:
> case internal::bool_type:
> handle_int_type_spec(
> type_spec, internal::int_type_checker<decltype(eh)>(eh));
> break;
> case internal::char_type:
> handle_char_specs(
> specs_,
> internal::char_specs_checker<decltype(eh), decltype(type_spec)>(
> type_spec, eh));
> break;
> case internal::double_type:
> case internal::long_double_type:
> handle_float_type_spec(
> type_spec, internal::float_type_checker<decltype(eh)>(eh));
> break;
> case internal::cstring_type:
> internal::handle_cstring_type_spec(
> type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
> break;
> case internal::string_type:
> internal::check_string_type_spec(type_spec, eh);
> break;
> case internal::pointer_type:
> internal::check_pointer_type_spec(type_spec, eh);
> break;
> case internal::custom_type:
>
>
> break;
> }
> return pointer_from(it);
> }
>
> template <typename FormatContext>
> auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
> internal::handle_dynamic_spec<internal::width_checker>(
> specs_.width_, specs_.width_ref, ctx);
> internal::handle_dynamic_spec<internal::precision_checker>(
> specs_.precision_, specs_.precision_ref, ctx);
> typedef output_range<typename FormatContext::iterator,
> typename FormatContext::char_type> range_type;
> visit(arg_formatter<range_type>(ctx, specs_),
> internal::make_arg<FormatContext>(val));
> return ctx.out();
> }
>
> private:
> internal::dynamic_format_specs<Char> specs_;
>};
>
>template <typename T, typename Char>
>struct formatter<T, Char,
> typename std::enable_if<internal::format_enum<T>::value>::type>
> : public formatter<int, Char> {
> template <typename ParseContext>
> auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
> return ctx.begin();
> }
>};
># 3255 "/usr/local/include/fmt/format.h" 3
>template <typename Char = char>
>class dynamic_formatter {
> private:
> struct null_handler: internal::error_handler {
> void on_align(alignment) {}
> void on_plus() {}
> void on_minus() {}
> void on_space() {}
> void on_hash() {}
> };
>
> public:
> template <typename ParseContext>
> auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
> auto it = internal::null_terminating_iterator<Char>(ctx);
>
> internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
> it = parse_format_specs(it, handler);
> return pointer_from(it);
> }
>
> template <typename T, typename FormatContext>
> auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
> handle_specs(ctx);
> internal::specs_checker<null_handler>
> checker(null_handler(), internal::get_type<FormatContext, T>::value);
> checker.on_align(specs_.align());
> if (specs_.flags_ == 0) {
>
> } else if (specs_.flag(SIGN_FLAG)) {
> if (specs_.flag(PLUS_FLAG))
> checker.on_plus();
> else
> checker.on_space();
> } else if (specs_.flag(MINUS_FLAG)) {
> checker.on_minus();
> } else if (specs_.flag(HASH_FLAG)) {
> checker.on_hash();
> }
> if (specs_.precision_ != -1)
> checker.end_precision();
> typedef output_range<typename FormatContext::iterator,
> typename FormatContext::char_type> range;
> visit(arg_formatter<range>(ctx, specs_),
> internal::make_arg<FormatContext>(val));
> return ctx.out();
> }
>
> private:
> template <typename Context>
> void handle_specs(Context &ctx) {
> internal::handle_dynamic_spec<internal::width_checker>(
> specs_.width_, specs_.width_ref, ctx);
> internal::handle_dynamic_spec<internal::precision_checker>(
> specs_.precision_, specs_.precision_ref, ctx);
> }
>
> internal::dynamic_format_specs<Char> specs_;
>};
>
>template <typename Range, typename Char>
>typename basic_format_context<Range, Char>::format_arg
> basic_format_context<Range, Char>::get_arg(basic_string_view<char_type> name) {
> map_.init(this->args());
> format_arg arg = map_.find(name);
> if (arg.type() == internal::none_type)
> this->on_error("argument not found");
> return arg;
>}
>
>template <typename ArgFormatter, typename Char, typename Context>
>struct format_handler : internal::error_handler {
> typedef internal::null_terminating_iterator<Char> iterator;
> typedef typename ArgFormatter::range range;
>
> format_handler(range r, basic_string_view<Char> str,
> basic_format_args<Context> format_args)
> : context(r.begin(), str, format_args) {}
>
> void on_text(iterator begin, iterator end) {
> size_t size = end - begin;
> auto out = context.out();
> auto &&it = internal::reserve(out, size);
> it = std::copy_n(begin, size, it);
> context.advance_to(out);
> }
>
> void on_arg_id() { arg = context.next_arg(); }
> void on_arg_id(unsigned id) {
> context.parse_context().check_arg_id(id);
> arg = context.get_arg(id);
> }
> void on_arg_id(basic_string_view<Char> id) {
> arg = context.get_arg(id);
> }
>
> void on_replacement_field(iterator it) {
> context.parse_context().advance_to(pointer_from(it));
> if (visit(internal::custom_formatter<Char, Context>(context), arg))
> return;
> basic_format_specs<Char> specs;
> context.advance_to(visit(ArgFormatter(context, specs), arg));
> }
>
> iterator on_format_specs(iterator it) {
> auto& parse_ctx = context.parse_context();
> parse_ctx.advance_to(pointer_from(it));
> if (visit(internal::custom_formatter<Char, Context>(context), arg))
> return iterator(parse_ctx);
> basic_format_specs<Char> specs;
> using internal::specs_handler;
> internal::specs_checker<specs_handler<Context>>
> handler(specs_handler<Context>(specs, context), arg.type());
> it = parse_format_specs(it, handler);
> if (*it != '}')
> on_error("missing '}' in format string");
> parse_ctx.advance_to(pointer_from(it));
> context.advance_to(visit(ArgFormatter(context, specs), arg));
> return it;
> }
>
> Context context;
> basic_format_arg<Context> arg;
>};
>
>
>template <typename ArgFormatter, typename Char, typename Context>
>typename Context::iterator vformat_to(typename ArgFormatter::range out,
> basic_string_view<Char> format_str,
> basic_format_args<Context> args) {
> typedef internal::null_terminating_iterator<Char> iterator;
> format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
> parse_format_string(iterator(format_str.begin(), format_str.end()), h);
> return h.context.out();
>}
>
>
>
>
>template <typename T>
>inline const void *ptr(const T *p) { return p; }
>
>template <typename It, typename Char>
>struct arg_join {
> It begin;
> It end;
> basic_string_view<Char> sep;
>
> arg_join(It begin, It end, basic_string_view<Char> sep)
> : begin(begin), end(end), sep(sep) {}
>};
>
>template <typename It, typename Char>
>struct formatter<arg_join<It, Char>, Char>:
> formatter<typename std::iterator_traits<It>::value_type, Char> {
> template <typename FormatContext>
> auto format(const arg_join<It, Char> &value, FormatContext &ctx)
> -> decltype(ctx.out()) {
> typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
> auto it = value.begin;
> auto out = ctx.out();
> if (it != value.end) {
> out = base::format(*it++, ctx);
> while (it != value.end) {
> out = std::copy(value.sep.begin(), value.sep.end(), out);
> ctx.advance_to(out);
> out = base::format(*it++, ctx);
> }
> }
> return out;
> }
>};
>
>template <typename It>
>arg_join<It, char> join(It begin, It end, string_view sep) {
> return arg_join<It, char>(begin, end, sep);
>}
>
>template <typename It>
>arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
> return arg_join<It, wchar_t>(begin, end, sep);
>}
>
>
>
>template <typename Range>
>auto join(const Range &range, string_view sep)
> -> arg_join<decltype(internal::begin(range)), char> {
> return join(internal::begin(range), internal::end(range), sep);
>}
>
>template <typename Range>
>auto join(const Range &range, wstring_view sep)
> -> arg_join<decltype(internal::begin(range)), wchar_t> {
> return join(internal::begin(range), internal::end(range), sep);
>}
># 3464 "/usr/local/include/fmt/format.h" 3
>template <typename T>
>std::string to_string(const T &value) {
> std::string str;
> internal::container_buffer<std::string> buf(str);
> writer(buf).write(value);
> return str;
>}
>
>
>
>
>template <typename T>
>std::wstring to_wstring(const T &value) {
> std::wstring str;
> internal::container_buffer<std::wstring> buf(str);
> wwriter(buf).write(value);
> return str;
>}
>
>template <typename Char>
>std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer) {
> return std::basic_string<Char>(buffer.data(), buffer.size());
>}
>
>inline format_context::iterator vformat_to(
> internal::buffer &buf, string_view format_str, format_args args) {
> typedef back_insert_range<internal::buffer> range;
> return vformat_to<arg_formatter<range>>(buf, format_str, args);
>}
>
>inline wformat_context::iterator vformat_to(
> internal::wbuffer &buf, wstring_view format_str, wformat_args args) {
> typedef back_insert_range<internal::wbuffer> range;
> return vformat_to<arg_formatter<range>>(buf, format_str, args);
>}
>
>template <typename... Args>
>inline format_context::iterator format_to(
> memory_buffer &buf, string_view format_str, const Args & ... args) {
> return vformat_to(buf, format_str, make_format_args(args...));
>}
>
>template <typename... Args>
>inline wformat_context::iterator format_to(
> wmemory_buffer &buf, wstring_view format_str, const Args & ... args) {
> return vformat_to(buf, format_str, make_format_args<wformat_context>(args...));
>}
>
>template <typename OutputIt, typename Char = char>
>
>struct format_context_t { typedef basic_format_context<OutputIt, Char> type; };
>
>template <typename OutputIt, typename Char = char>
>
>struct format_args_t {
> typedef basic_format_args<
> typename format_context_t<OutputIt, Char>::type> type;
>};
>
>template <typename OutputIt, typename... Args>
>inline OutputIt vformat_to(OutputIt out, string_view format_str,
> typename format_args_t<OutputIt>::type args) {
> typedef output_range<OutputIt, char> range;
> return vformat_to<arg_formatter<range>>(range(out), format_str, args);
>}
>template <typename OutputIt, typename... Args>
>inline OutputIt vformat_to(
> OutputIt out, wstring_view format_str,
> typename format_args_t<OutputIt, wchar_t>::type args) {
> typedef output_range<OutputIt, wchar_t> range;
> return vformat_to<arg_formatter<range>>(range(out), format_str, args);
>}
># 3548 "/usr/local/include/fmt/format.h" 3
>template <typename OutputIt, typename... Args>
>inline OutputIt format_to(OutputIt out, string_view format_str,
> const Args & ... args) {
> return vformat_to(out, format_str,
> make_format_args<typename format_context_t<OutputIt>::type>(args...));
>}
>
>template <typename Container, typename... Args>
>inline typename std::enable_if<
> is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
> format_to(std::back_insert_iterator<Container> out,
> string_view format_str, const Args & ... args) {
> return vformat_to(out, format_str, make_format_args<format_context>(args...));
>}
>
>template <typename Container, typename... Args>
>inline typename std::enable_if<
> is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
> format_to(std::back_insert_iterator<Container> out,
> wstring_view format_str, const Args & ... args) {
> return vformat_to(out, format_str, make_format_args<wformat_context>(args...));
>}
>
>template <typename OutputIt>
>struct format_to_n_result {
>
> OutputIt out;
>
> std::size_t size;
>};
>
>template <typename OutputIt>
>using format_to_n_context = typename fmt::format_context_t<
> fmt::internal::truncating_iterator<OutputIt>>::type;
>
>template <typename OutputIt>
>using format_to_n_args = fmt::basic_format_args<format_to_n_context<OutputIt>>;
>
>template <typename OutputIt, typename ...Args>
>inline format_arg_store<format_to_n_context<OutputIt>, Args...>
> make_format_to_n_args(const Args & ... args) {
> return format_arg_store<format_to_n_context<OutputIt>, Args...>(args...);
>}
>
>template <typename OutputIt, typename... Args>
>inline format_to_n_result<OutputIt> vformat_to_n(
> OutputIt out, std::size_t n, string_view format_str,
> format_to_n_args<OutputIt> args) {
> typedef internal::truncating_iterator<OutputIt> It;
> auto it = vformat_to(It(out, n), format_str, args);
> return {it.base(), it.count()};
>}
># 3608 "/usr/local/include/fmt/format.h" 3
>template <typename OutputIt, typename... Args>
>inline format_to_n_result<OutputIt> format_to_n(
> OutputIt out, std::size_t n, string_view format_str, const Args &... args) {
> return vformat_to_n<OutputIt>(
> out, n, format_str, make_format_to_n_args<OutputIt>(args...));
>}
>template <typename OutputIt, typename... Args>
>inline format_to_n_result<OutputIt> format_to_n(
> OutputIt out, std::size_t n, wstring_view format_str, const Args &... args) {
> typedef internal::truncating_iterator<OutputIt> It;
> auto it = vformat_to(It(out, n), format_str,
> make_format_args<typename format_context_t<It, wchar_t>::type>(args...));
> return {it.base(), it.count()};
>}
>
>inline std::string vformat(string_view format_str, format_args args) {
> memory_buffer buffer;
> vformat_to(buffer, format_str, args);
> return fmt::to_string(buffer);
>}
>
>inline std::wstring vformat(wstring_view format_str, wformat_args args) {
> wmemory_buffer buffer;
> vformat_to(buffer, format_str, args);
> return to_string(buffer);
>}
>
>template <typename String, typename... Args>
>inline typename std::enable_if<
> internal::is_format_string<String>::value, std::string>::type
> format(String format_str, const Args & ... args) {
> internal::check_format_string<Args...>(format_str);
> return vformat(format_str.data(), make_format_args(args...));
>}
>
>template <typename String, typename... Args>
>inline typename std::enable_if<internal::is_format_string<String>::value>::type
> print(String format_str, const Args & ... args) {
> internal::check_format_string<Args...>(format_str);
> return vprint(format_str.data(), make_format_args(args...));
>}
>
>
>
>
>
>template <typename... Args>
>inline std::size_t formatted_size(string_view format_str,
> const Args & ... args) {
> auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
> return it.count();
>}
>
>
>namespace internal {
># 3679 "/usr/local/include/fmt/format.h" 3
>template <typename Char>
>struct udl_formatter {
> const Char *str;
>
> template <typename... Args>
> auto operator()(Args && ... args) const
> -> decltype(format(str, std::forward<Args>(args)...)) {
> return format(str, std::forward<Args>(args)...);
> }
>};
>
>
>template <typename Char>
>struct udl_arg {
> const Char *str;
>
> template <typename T>
> named_arg<T, Char> operator=(T &&value) const {
> return {str, std::forward<T>(value)};
> }
>};
>
>}
>
>inline namespace literals {
># 3721 "/usr/local/include/fmt/format.h" 3
>inline internal::udl_formatter<char>
>operator"" _format(const char *s, std::size_t) { return {s}; }
>inline internal::udl_formatter<wchar_t>
>operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
># 3737 "/usr/local/include/fmt/format.h" 3
>inline internal::udl_arg<char>
>operator"" _a(const char *s, std::size_t) { return {s}; }
>inline internal::udl_arg<wchar_t>
>operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
>}
>
>}}
># 3777 "/usr/local/include/fmt/format.h" 3
>#pragma GCC diagnostic pop
># 4 "h2-client.cpp" 2
>
># 1 "/usr/local/include/nghttp2/asio_http2_client.h" 1 3
># 28 "/usr/local/include/nghttp2/asio_http2_client.h" 3
># 1 "/usr/local/include/nghttp2/asio_http2.h" 1 3
># 31 "/usr/local/include/nghttp2/asio_http2.h" 3
># 1 "/usr/include/c++/8/vector" 1 3
># 58 "/usr/include/c++/8/vector" 3
> 
># 59 "/usr/include/c++/8/vector" 3
>
>
>
>
>
># 1 "/usr/include/c++/8/bits/stl_vector.h" 1 3
># 74 "/usr/include/c++/8/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
> : public _Tp_alloc_type
> {
> pointer _M_start;
> pointer _M_finish;
> pointer _M_end_of_storage;
>
> _Vector_impl()
> : _Tp_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
> { }
>
> _Vector_impl(_Tp_alloc_type const& __a) noexcept
> : _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
> { }
>
>
> _Vector_impl(_Tp_alloc_type&& __a) noexcept
> : _Tp_alloc_type(std::move(__a)),
> _M_start(), _M_finish(), _M_end_of_storage()
> { }
>
>
> void _M_swap_data(_Vector_impl& __x) noexcept
> {
> std::swap(_M_start, __x._M_start);
> std::swap(_M_finish, __x._M_finish);
> std::swap(_M_end_of_storage, __x._M_end_of_storage);
> }
># 231 "/usr/include/c++/8/bits/stl_vector.h" 3
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Tp_alloc_type&
> _M_get_Tp_allocator() noexcept
> { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
>
> const _Tp_alloc_type&
> _M_get_Tp_allocator() const noexcept
> { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Tp_allocator()); }
>
> _Vector_base()
> : _M_impl() { }
>
> _Vector_base(const allocator_type& __a) noexcept
> : _M_impl(__a) { }
>
> _Vector_base(size_t __n)
> : _M_impl()
> { _M_create_storage(__n); }
>
> _Vector_base(size_t __n, const allocator_type& __a)
> : _M_impl(__a)
> { _M_create_storage(__n); }
>
>
> _Vector_base(_Tp_alloc_type&& __a) noexcept
> : _M_impl(std::move(__a)) { }
>
> _Vector_base(_Vector_base&& __x) noexcept
> : _M_impl(std::move(__x._M_get_Tp_allocator()))
> { this->_M_impl._M_swap_data(__x._M_impl); }
>
> _Vector_base(_Vector_base&& __x, const allocator_type& __a)
> : _M_impl(__a)
> {
> if (__x.get_allocator() == __a)
> this->_M_impl._M_swap_data(__x._M_impl);
> else
> {
> size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
> _M_create_storage(__n);
> }
> }
>
>
> ~_Vector_base() noexcept
> {
> _M_deallocate(_M_impl._M_start,
> _M_impl._M_end_of_storage - _M_impl._M_start);
> }
>
> public:
> _Vector_impl _M_impl;
>
> pointer
> _M_allocate(size_t __n)
> {
> typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
> return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
> }
>
> void
> _M_deallocate(pointer __p, size_t __n)
> {
> typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
> if (__p)
> _Tr::deallocate(_M_impl, __p, __n);
> }
>
> private:
> 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;
> }
> };
># 338 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class vector : protected _Vector_base<_Tp, _Alloc>
> {
># 351 "/usr/include/c++/8/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;
>
> protected:
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_M_impl;
> using _Base::_M_get_Tp_allocator;
>
> public:
>
>
>
>
>
>
> vector()
>
> noexcept(is_nothrow_default_constructible<_Alloc>::value)
>
> : _Base() { }
>
>
>
>
>
> explicit
> vector(const allocator_type& __a) noexcept
> : _Base(__a) { }
># 414 "/usr/include/c++/8/bits/stl_vector.h" 3
> explicit
> vector(size_type __n, const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> { _M_default_initialize(__n); }
># 427 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> { _M_fill_initialize(__n, __value); }
># 458 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector(const vector& __x)
> : _Base(__x.size(),
> _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
> {
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
># 476 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector(vector&& __x) noexcept
> : _Base(std::move(__x)) { }
>
>
> vector(const vector& __x, const allocator_type& __a)
> : _Base(__x.size(), __a)
> {
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
> vector(vector&& __rv, const allocator_type& __m)
> noexcept(_Alloc_traits::_S_always_equal())
> : _Base(std::move(__rv), __m)
> {
> if (__rv.get_allocator() != __m)
> {
> this->_M_impl._M_finish =
> std::__uninitialized_move_a(__rv.begin(), __rv.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> __rv.clear();
> }
> }
># 515 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector(initializer_list<value_type> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_range_initialize(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
># 541 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { _M_initialize_dispatch(__first, __last, __false_type()); }
># 565 "/usr/include/c++/8/bits/stl_vector.h" 3
> ~vector() noexcept
> {
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> ;
> }
># 581 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector&
> operator=(const vector& __x);
># 595 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector&
> operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
> {
> constexpr bool __move_storage =
> _Alloc_traits::_S_propagate_on_move_assign()
> || _Alloc_traits::_S_always_equal();
> _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
> return *this;
> }
># 616 "/usr/include/c++/8/bits/stl_vector.h" 3
> vector&
> operator=(initializer_list<value_type> __l)
> {
> this->_M_assign_aux(__l.begin(), __l.end(),
> random_access_iterator_tag());
> return *this;
> }
># 635 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 652 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> assign(_InputIterator __first, _InputIterator __last)
> { _M_assign_dispatch(__first, __last, __false_type()); }
># 680 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> assign(initializer_list<value_type> __l)
> {
> this->_M_assign_aux(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
>
>
>
> using _Base::get_allocator;
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
> size_type
> size() const noexcept
> { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
>
>
> size_type
> max_size() const noexcept
> { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
># 823 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> resize(size_type __new_size)
> {
> if (__new_size > size())
> _M_default_append(__new_size - size());
> else if (__new_size < size())
> _M_erase_at_end(this->_M_impl._M_start + __new_size);
> }
># 843 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> resize(size_type __new_size, const value_type& __x)
> {
> if (__new_size > size())
> _M_fill_insert(end(), __new_size - size(), __x);
> else if (__new_size < size())
> _M_erase_at_end(this->_M_impl._M_start + __new_size);
> }
># 875 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
>
>
>
>
> size_type
> capacity() const noexcept
> { return size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start); }
>
>
>
>
>
> bool
> empty() const noexcept
> { return begin() == end(); }
># 914 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> reserve(size_type __n);
># 929 "/usr/include/c++/8/bits/stl_vector.h" 3
> reference
> operator[](size_type __n) noexcept
> {
> ;
> return *(this->_M_impl._M_start + __n);
> }
># 947 "/usr/include/c++/8/bits/stl_vector.h" 3
> const_reference
> operator[](size_type __n) const noexcept
> {
> ;
> return *(this->_M_impl._M_start + __n);
> }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
>
> ,
> __n, this->size());
> }
>
> public:
># 978 "/usr/include/c++/8/bits/stl_vector.h" 3
> reference
> at(size_type __n)
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
># 996 "/usr/include/c++/8/bits/stl_vector.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front() noexcept
> {
> ;
> return *begin();
> }
>
>
>
>
>
> const_reference
> front() const noexcept
> {
> ;
> return *begin();
> }
>
>
>
>
>
> reference
> back() noexcept
> {
> ;
> return *(end() - 1);
> }
>
>
>
>
>
> const_reference
> back() const noexcept
> {
> ;
> return *(end() - 1);
> }
># 1054 "/usr/include/c++/8/bits/stl_vector.h" 3
> _Tp*
> data() noexcept
> { return _M_data_ptr(this->_M_impl._M_start); }
>
> const _Tp*
> data() const noexcept
> { return _M_data_ptr(this->_M_impl._M_start); }
># 1073 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> push_back(const value_type& __x)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> ;
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> __x);
> ++this->_M_impl._M_finish;
> ;
> }
> else
> _M_realloc_insert(end(), __x);
> }
>
>
> void
> push_back(value_type&& __x)
> { emplace_back(std::move(__x)); }
>
> template<typename... _Args>
>
> reference
>
>
>
> emplace_back(_Args&&... __args);
># 1111 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> pop_back() noexcept
> {
> ;
> --this->_M_impl._M_finish;
> _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
> ;
> }
># 1133 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename... _Args>
> iterator
> emplace(const_iterator __position, _Args&&... __args)
> { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
># 1149 "/usr/include/c++/8/bits/stl_vector.h" 3
> iterator
> insert(const_iterator __position, const value_type& __x);
># 1179 "/usr/include/c++/8/bits/stl_vector.h" 3
> iterator
> insert(const_iterator __position, value_type&& __x)
> { return _M_insert_rval(__position, std::move(__x)); }
># 1196 "/usr/include/c++/8/bits/stl_vector.h" 3
> iterator
> insert(const_iterator __position, initializer_list<value_type> __l)
> {
> auto __offset = __position - cbegin();
> _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
> std::random_access_iterator_tag());
> return begin() + __offset;
> }
># 1221 "/usr/include/c++/8/bits/stl_vector.h" 3
> iterator
> insert(const_iterator __position, size_type __n, const value_type& __x)
> {
> difference_type __offset = __position - cbegin();
> _M_fill_insert(begin() + __offset, __n, __x);
> return begin() + __offset;
> }
># 1263 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> iterator
> insert(const_iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
> difference_type __offset = __position - cbegin();
> _M_insert_dispatch(begin() + __offset,
> __first, __last, __false_type());
> return begin() + __offset;
> }
># 1315 "/usr/include/c++/8/bits/stl_vector.h" 3
> iterator
>
> erase(const_iterator __position)
> { return _M_erase(begin() + (__position - cbegin())); }
># 1342 "/usr/include/c++/8/bits/stl_vector.h" 3
> iterator
>
> erase(const_iterator __first, const_iterator __last)
> {
> const auto __beg = begin();
> const auto __cbeg = cbegin();
> return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
> }
># 1366 "/usr/include/c++/8/bits/stl_vector.h" 3
> void
> swap(vector& __x) noexcept
> {
>
>
> ;
>
> this->_M_impl._M_swap_data(__x._M_impl);
> _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_erase_at_end(this->_M_impl._M_start); }
>
> protected:
>
>
>
>
> template<typename _ForwardIterator>
> pointer
> _M_allocate_and_copy(size_type __n,
> _ForwardIterator __first, _ForwardIterator __last)
> {
> pointer __result = this->_M_allocate(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last, __result,
> _M_get_Tp_allocator());
> return __result;
> }
> catch(...)
> {
> _M_deallocate(__result, __n);
> throw;
> }
> }
># 1419 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
> {
> this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
> this->_M_impl._M_end_of_storage =
> this->_M_impl._M_start + static_cast<size_type>(__n);
> _M_fill_initialize(static_cast<size_type>(__n), __value);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
>
> emplace_back(*__first);
>
>
>
> }
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
>
> void
> _M_fill_initialize(size_type __n, const value_type& __value)
> {
> this->_M_impl._M_finish =
> std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
> _M_get_Tp_allocator());
> }
>
>
>
> void
> _M_default_initialize(size_type __n)
> {
> this->_M_impl._M_finish =
> std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
> _M_get_Tp_allocator());
> }
># 1497 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
>
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
> __true_type)
> { _M_fill_insert(__pos, __n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos, _InputIterator __first,
> _InputIterator __last, __false_type)
> {
> _M_range_insert(__pos, __first, __last,
> std::__iterator_category(__first));
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
>
> void
> _M_default_append(size_type __n);
>
> bool
> _M_shrink_to_fit();
># 1584 "/usr/include/c++/8/bits/stl_vector.h" 3
> struct _Temporary_value
> {
> template<typename... _Args>
> explicit
> _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
> {
> _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
> std::forward<_Args>(__args)...);
> }
>
> ~_Temporary_value()
> { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
>
> value_type&
> _M_val() { return *reinterpret_cast<_Tp*>(&__buf); }
>
> private:
> pointer
> _M_ptr() { return pointer_traits<pointer>::pointer_to(_M_val()); }
>
> vector* _M_this;
> typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __buf;
> };
>
>
>
> template<typename _Arg>
> void
> _M_insert_aux(iterator __position, _Arg&& __arg);
>
> template<typename... _Args>
> void
> _M_realloc_insert(iterator __position, _Args&&... __args);
>
>
> iterator
> _M_insert_rval(const_iterator __position, value_type&& __v);
>
>
> template<typename... _Args>
> iterator
> _M_emplace_aux(const_iterator __position, _Args&&... __args);
>
>
> iterator
> _M_emplace_aux(const_iterator __position, value_type&& __v)
> { return _M_insert_rval(__position, std::move(__v)); }
>
>
>
> size_type
> _M_check_len(size_type __n, const char* __s) const
> {
> if (max_size() - size() < __n)
> __throw_length_error((__s));
>
> const size_type __len = size() + std::max(size(), __n);
> return (__len < size() || __len > max_size()) ? max_size() : __len;
> }
>
>
>
>
>
> void
> _M_erase_at_end(pointer __pos) noexcept
> {
> if (size_type __n = this->_M_impl._M_finish - __pos)
> {
> std::_Destroy(__pos, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = __pos;
> ;
> }
> }
>
> iterator
> _M_erase(iterator __position);
>
> iterator
> _M_erase(iterator __first, iterator __last);
>
>
> private:
>
>
>
> void
> _M_move_assign(vector&& __x, std::true_type) noexcept
> {
> vector __tmp(get_allocator());
> this->_M_impl._M_swap_data(__tmp._M_impl);
> this->_M_impl._M_swap_data(__x._M_impl);
> std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
> }
>
>
>
> void
> _M_move_assign(vector&& __x, std::false_type)
> {
> if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
> _M_move_assign(std::move(__x), std::true_type());
> else
> {
>
>
> this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
> std::__make_move_if_noexcept_iterator(__x.end()));
> __x.clear();
> }
> }
>
>
> template<typename _Up>
> _Up*
> _M_data_ptr(_Up* __ptr) const noexcept
> { return __ptr; }
>
>
> template<typename _Ptr>
> typename std::pointer_traits<_Ptr>::element_type*
> _M_data_ptr(_Ptr __ptr) const
> { return empty() ? nullptr : std::__to_address(__ptr); }
># 1724 "/usr/include/c++/8/bits/stl_vector.h" 3
> };
>
>
> template<typename _InputIterator, typename _ValT
> = typename iterator_traits<_InputIterator>::value_type,
> typename _Allocator = allocator<_ValT>,
> typename = _RequireInputIter<_InputIterator>,
> typename = _RequireAllocator<_Allocator>>
> vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
> -> vector<_ValT, _Allocator>;
># 1746 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return (__x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin())); }
># 1763 "/usr/include/c++/8/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
>
>}
># 65 "/usr/include/c++/8/vector" 2 3
># 1 "/usr/include/c++/8/bits/stl_bvector.h" 1 3
># 64 "/usr/include/c++/8/bits/stl_bvector.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> typedef unsigned long _Bit_type;
> enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
>
> struct _Bit_reference
> {
> _Bit_type * _M_p;
> _Bit_type _M_mask;
>
> _Bit_reference(_Bit_type * __x, _Bit_type __y)
> : _M_p(__x), _M_mask(__y) { }
>
> _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
>
> operator bool() const noexcept
> { return !!(*_M_p & _M_mask); }
>
> _Bit_reference&
> operator=(bool __x) noexcept
> {
> if (__x)
> *_M_p |= _M_mask;
> else
> *_M_p &= ~_M_mask;
> return *this;
> }
>
> _Bit_reference&
> operator=(const _Bit_reference& __x) noexcept
> { return *this = bool(__x); }
>
> bool
> operator==(const _Bit_reference& __x) const
> { return bool(*this) == bool(__x); }
>
> bool
> operator<(const _Bit_reference& __x) const
> { return !bool(*this) && bool(__x); }
>
> void
> flip() noexcept
> { *_M_p ^= _M_mask; }
> };
>
>
> inline void
> swap(_Bit_reference __x, _Bit_reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> inline void
> swap(_Bit_reference __x, bool& __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> inline void
> swap(bool& __x, _Bit_reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
>
> struct _Bit_iterator_base
> : public std::iterator<std::random_access_iterator_tag, bool>
> {
> _Bit_type * _M_p;
> unsigned int _M_offset;
>
> _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
> : _M_p(__x), _M_offset(__y) { }
>
> void
> _M_bump_up()
> {
> if (_M_offset++ == int(_S_word_bit) - 1)
> {
> _M_offset = 0;
> ++_M_p;
> }
> }
>
> void
> _M_bump_down()
> {
> if (_M_offset-- == 0)
> {
> _M_offset = int(_S_word_bit) - 1;
> --_M_p;
> }
> }
>
> void
> _M_incr(ptrdiff_t __i)
> {
> difference_type __n = __i + _M_offset;
> _M_p += __n / int(_S_word_bit);
> __n = __n % int(_S_word_bit);
> if (__n < 0)
> {
> __n += int(_S_word_bit);
> --_M_p;
> }
> _M_offset = static_cast<unsigned int>(__n);
> }
>
> bool
> operator==(const _Bit_iterator_base& __i) const
> { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
>
> bool
> operator<(const _Bit_iterator_base& __i) const
> {
> return _M_p < __i._M_p
> || (_M_p == __i._M_p && _M_offset < __i._M_offset);
> }
>
> bool
> operator!=(const _Bit_iterator_base& __i) const
> { return !(*this == __i); }
>
> bool
> operator>(const _Bit_iterator_base& __i) const
> { return __i < *this; }
>
> bool
> operator<=(const _Bit_iterator_base& __i) const
> { return !(__i < *this); }
>
> bool
> operator>=(const _Bit_iterator_base& __i) const
> { return !(*this < __i); }
> };
>
> inline ptrdiff_t
> operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
> {
> return (int(_S_word_bit) * (__x._M_p - __y._M_p)
> + __x._M_offset - __y._M_offset);
> }
>
> struct _Bit_iterator : public _Bit_iterator_base
> {
> typedef _Bit_reference reference;
> typedef _Bit_reference* pointer;
> typedef _Bit_iterator iterator;
>
> _Bit_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> iterator
> _M_const_cast() const
> { return *this; }
>
> reference
> operator*() const
> { return reference(_M_p, 1UL << _M_offset); }
>
> iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> iterator
> operator++(int)
> {
> iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> iterator
> operator--(int)
> {
> iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> iterator
> operator+(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp += __i;
> }
>
> iterator
> operator-(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_iterator
> operator+(ptrdiff_t __n, const _Bit_iterator& __x)
> { return __x + __n; }
>
> struct _Bit_const_iterator : public _Bit_iterator_base
> {
> typedef bool reference;
> typedef bool const_reference;
> typedef const bool* pointer;
> typedef _Bit_const_iterator const_iterator;
>
> _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> _Bit_const_iterator(const _Bit_iterator& __x)
> : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
>
> _Bit_iterator
> _M_const_cast() const
> { return _Bit_iterator(_M_p, _M_offset); }
>
> const_reference
> operator*() const
> { return _Bit_reference(_M_p, 1UL << _M_offset); }
>
> const_iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> const_iterator
> operator++(int)
> {
> const_iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> const_iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> const_iterator
> operator--(int)
> {
> const_iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> const_iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> const_iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> const_iterator
> operator+(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp += __i;
> }
>
> const_iterator
> operator-(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> const_reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_const_iterator
> operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
> { return __x + __n; }
>
> inline void
> __fill_bvector(_Bit_type * __v,
> unsigned int __first, unsigned int __last, bool __x)
> {
> const _Bit_type __fmask = ~0ul << __first;
> const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
> const _Bit_type __mask = __fmask & __lmask;
>
> if (__x)
> *__v |= __mask;
> else
> *__v &= ~__mask;
> }
>
> inline void
> fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
> {
> if (__first._M_p != __last._M_p)
> {
> _Bit_type* __first_p = __first._M_p;
> if (__first._M_offset != 0)
> __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
>
> __builtin_memset(__first_p, __x ? ~0 : 0,
> (__last._M_p - __first_p) * sizeof(_Bit_type));
>
> if (__last._M_offset != 0)
> __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
> }
> else if (__first._M_offset != __last._M_offset)
> __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
> }
>
> template<typename _Alloc>
> struct _Bvector_base
> {
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<_Bit_type>::other _Bit_alloc_type;
> typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
> _Bit_alloc_traits;
> typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
>
> struct _Bvector_impl_data
> {
> _Bit_iterator _M_start;
> _Bit_iterator _M_finish;
> _Bit_pointer _M_end_of_storage;
>
> _Bvector_impl_data() noexcept
> : _M_start(), _M_finish(), _M_end_of_storage()
> { }
>
>
> _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
> : _M_start(__x._M_start), _M_finish(__x._M_finish)
> , _M_end_of_storage(__x._M_end_of_storage)
> { __x._M_reset(); }
>
> void
> _M_move_data(_Bvector_impl_data&& __x) noexcept
> {
> this->_M_start = __x._M_start;
> this->_M_finish = __x._M_finish;
> this->_M_end_of_storage = __x._M_end_of_storage;
> __x._M_reset();
> }
>
>
> void
> _M_reset() noexcept
> {
> _M_start = _M_finish = _Bit_iterator();
> _M_end_of_storage = _Bit_pointer();
> }
> };
>
> struct _Bvector_impl
> : public _Bit_alloc_type, public _Bvector_impl_data
> {
> public:
> _Bvector_impl()
> noexcept(noexcept(_Bit_alloc_type()))
> : _Bit_alloc_type()
> { }
>
> _Bvector_impl(const _Bit_alloc_type& __a) noexcept
> : _Bit_alloc_type(__a)
> { }
>
>
> _Bvector_impl(_Bvector_impl&&) = default;
>
>
> _Bit_type*
> _M_end_addr() const noexcept
> {
> if (this->_M_end_of_storage)
> return std::__addressof(this->_M_end_of_storage[-1]) + 1;
> return 0;
> }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Bit_alloc_type&
> _M_get_Bit_allocator() noexcept
> { return this->_M_impl; }
>
> const _Bit_alloc_type&
> _M_get_Bit_allocator() const noexcept
> { return this->_M_impl; }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Bit_allocator()); }
>
>
> _Bvector_base() = default;
>
>
>
>
> _Bvector_base(const allocator_type& __a)
> : _M_impl(__a) { }
>
>
> _Bvector_base(_Bvector_base&&) = default;
>
>
> ~_Bvector_base()
> { this->_M_deallocate(); }
>
> protected:
> _Bvector_impl _M_impl;
>
> _Bit_pointer
> _M_allocate(size_t __n)
> { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
>
> void
> _M_deallocate()
> {
> if (_M_impl._M_start._M_p)
> {
> const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
> _Bit_alloc_traits::deallocate(_M_impl,
> _M_impl._M_end_of_storage - __n,
> __n);
> _M_impl._M_reset();
> }
> }
>
>
> void
> _M_move_data(_Bvector_base&& __x) noexcept
> { _M_impl._M_move_data(std::move(__x._M_impl)); }
>
>
> static size_t
> _S_nword(size_t __n)
> { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
> };
>
>
>
>}
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
># 587 "/usr/include/c++/8/bits/stl_bvector.h" 3
> template<typename _Alloc>
> class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
> {
> typedef _Bvector_base<_Alloc> _Base;
> typedef typename _Base::_Bit_pointer _Bit_pointer;
> typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
>
>
> friend struct std::hash<vector>;
>
>
> public:
> typedef bool value_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Bit_reference reference;
> typedef bool const_reference;
> typedef _Bit_reference* pointer;
> typedef const bool* const_pointer;
> typedef _Bit_iterator iterator;
> typedef _Bit_const_iterator const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef _Alloc allocator_type;
>
> allocator_type
> get_allocator() const
> { return _Base::get_allocator(); }
>
> protected:
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_S_nword;
> using _Base::_M_get_Bit_allocator;
>
> public:
>
> vector() = default;
>
>
>
>
> explicit
> vector(const allocator_type& __a)
> : _Base(__a) { }
>
>
> explicit
> vector(size_type __n, const allocator_type& __a = allocator_type())
> : vector(__n, false, __a)
> { }
>
> vector(size_type __n, const bool& __value,
> const allocator_type& __a = allocator_type())
>
>
>
>
>
> : _Base(__a)
> {
> _M_initialize(__n);
> _M_initialize_value(__value);
> }
>
> vector(const vector& __x)
> : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
> {
> _M_initialize(__x.size());
> _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
> }
>
>
> vector(vector&&) = default;
>
> vector(vector&& __x, const allocator_type& __a)
> noexcept(_Bit_alloc_traits::_S_always_equal())
> : _Base(__a)
> {
> if (__x.get_allocator() == __a)
> this->_M_move_data(std::move(__x));
> else
> {
> _M_initialize(__x.size());
> _M_copy_aligned(__x.begin(), __x.end(), begin());
> __x.clear();
> }
> }
>
> vector(const vector& __x, const allocator_type& __a)
> : _Base(__a)
> {
> _M_initialize(__x.size());
> _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
> }
>
> vector(initializer_list<bool> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_initialize_range(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
>
>
>
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> { _M_initialize_dispatch(__first, __last, __false_type()); }
># 710 "/usr/include/c++/8/bits/stl_bvector.h" 3
> ~vector() noexcept { }
>
> vector&
> operator=(const vector& __x)
> {
> if (&__x == this)
> return *this;
>
> if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
> {
> if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
> {
> this->_M_deallocate();
> std::__alloc_on_copy(_M_get_Bit_allocator(),
> __x._M_get_Bit_allocator());
> _M_initialize(__x.size());
> }
> else
> std::__alloc_on_copy(_M_get_Bit_allocator(),
> __x._M_get_Bit_allocator());
> }
>
> if (__x.size() > capacity())
> {
> this->_M_deallocate();
> _M_initialize(__x.size());
> }
> this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
> begin());
> return *this;
> }
>
>
> vector&
> operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
> {
> if (_Bit_alloc_traits::_S_propagate_on_move_assign()
> || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
> {
> this->_M_deallocate();
> this->_M_move_data(std::move(__x));
> std::__alloc_on_move(_M_get_Bit_allocator(),
> __x._M_get_Bit_allocator());
> }
> else
> {
> if (__x.size() > capacity())
> {
> this->_M_deallocate();
> _M_initialize(__x.size());
> }
> this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
> begin());
> __x.clear();
> }
> return *this;
> }
>
> vector&
> operator=(initializer_list<bool> __l)
> {
> this->assign (__l.begin(), __l.end());
> return *this;
> }
>
>
>
>
>
>
> void
> assign(size_type __n, const bool& __x)
> { _M_fill_assign(__n, __x); }
>
>
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> void
> assign(_InputIterator __first, _InputIterator __last)
> { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
># 801 "/usr/include/c++/8/bits/stl_bvector.h" 3
> void
> assign(initializer_list<bool> __l)
> { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
>
>
> iterator
> begin() noexcept
> { return this->_M_impl._M_start; }
>
> const_iterator
> begin() const noexcept
> { return this->_M_impl._M_start; }
>
> iterator
> end() noexcept
> { return this->_M_impl._M_finish; }
>
> const_iterator
> end() const noexcept
> { return this->_M_impl._M_finish; }
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> const_iterator
> cbegin() const noexcept
> { return this->_M_impl._M_start; }
>
> const_iterator
> cend() const noexcept
> { return this->_M_impl._M_finish; }
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> size_type
> size() const noexcept
> { return size_type(end() - begin()); }
>
> size_type
> max_size() const noexcept
> {
> const size_type __isize =
> __gnu_cxx::__numeric_traits<difference_type>::__max
> - int(_S_word_bit) + 1;
> const size_type __asize
> = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
> return (__asize <= __isize / int(_S_word_bit)
> ? __asize * int(_S_word_bit) : __isize);
> }
>
> size_type
> capacity() const noexcept
> { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
> - begin()); }
>
> bool
> empty() const noexcept
> { return begin() == end(); }
>
> reference
> operator[](size_type __n)
> {
> return *iterator(this->_M_impl._M_start._M_p
> + __n / int(_S_word_bit), __n % int(_S_word_bit));
> }
>
> const_reference
> operator[](size_type __n) const
> {
> return *const_iterator(this->_M_impl._M_start._M_p
> + __n / int(_S_word_bit), __n % int(_S_word_bit));
> }
>
> protected:
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
>
> ,
> __n, this->size());
> }
>
> public:
> reference
> at(size_type __n)
> { _M_range_check(__n); return (*this)[__n]; }
>
> const_reference
> at(size_type __n) const
> { _M_range_check(__n); return (*this)[__n]; }
>
> void
> reserve(size_type __n)
> {
> if (__n > max_size())
> __throw_length_error(("vector::reserve"));
> if (capacity() < __n)
> _M_reallocate(__n);
> }
>
> reference
> front()
> { return *begin(); }
>
> const_reference
> front() const
> { return *begin(); }
>
> reference
> back()
> { return *(end() - 1); }
>
> const_reference
> back() const
> { return *(end() - 1); }
>
>
>
>
>
>
> void
> data() noexcept { }
>
> void
> push_back(bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(end(), __x);
> }
>
> void
> swap(vector& __x) noexcept
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_end_of_storage,
> __x._M_impl._M_end_of_storage);
> _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
> __x._M_get_Bit_allocator());
> }
>
>
> static void
> swap(reference __x, reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> iterator
>
> insert(const_iterator __position, const bool& __x = bool())
>
>
>
> {
> const difference_type __n = __position - begin();
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
> && __position == end())
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(__position._M_const_cast(), __x);
> return begin() + __n;
> }
>
>
> template<typename _InputIterator,
> typename = std::_RequireInputIter<_InputIterator>>
> iterator
> insert(const_iterator __position,
> _InputIterator __first, _InputIterator __last)
> {
> difference_type __offset = __position - cbegin();
> _M_insert_dispatch(__position._M_const_cast(),
> __first, __last, __false_type());
> return begin() + __offset;
> }
># 1017 "/usr/include/c++/8/bits/stl_bvector.h" 3
> iterator
> insert(const_iterator __position, size_type __n, const bool& __x)
> {
> difference_type __offset = __position - cbegin();
> _M_fill_insert(__position._M_const_cast(), __n, __x);
> return begin() + __offset;
> }
>
>
>
>
>
>
>
> iterator
> insert(const_iterator __p, initializer_list<bool> __l)
> { return this->insert(__p, __l.begin(), __l.end()); }
>
>
> void
> pop_back()
> { --this->_M_impl._M_finish; }
>
> iterator
>
> erase(const_iterator __position)
>
>
>
> { return _M_erase(__position._M_const_cast()); }
>
> iterator
>
> erase(const_iterator __first, const_iterator __last)
>
>
>
> { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
>
> void
> resize(size_type __new_size, bool __x = bool())
> {
> if (__new_size < size())
> _M_erase_at_end(begin() + difference_type(__new_size));
> else
> insert(end(), __new_size - size(), __x);
> }
>
>
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
> void
> flip() noexcept
> {
> _Bit_type * const __end = this->_M_impl._M_end_addr();
> for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
> *__p = ~*__p;
> }
>
> void
> clear() noexcept
> { _M_erase_at_end(begin()); }
>
>
> template<typename... _Args>
>
> reference
>
>
>
> emplace_back(_Args&&... __args)
> {
> push_back(bool(__args...));
>
> return back();
>
> }
>
> template<typename... _Args>
> iterator
> emplace(const_iterator __pos, _Args&&... __args)
> { return insert(__pos, bool(__args...)); }
>
>
> protected:
>
> iterator
> _M_copy_aligned(const_iterator __first, const_iterator __last,
> iterator __result)
> {
> _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
> return std::copy(const_iterator(__last._M_p, 0), __last,
> iterator(__q, 0));
> }
>
> void
> _M_initialize(size_type __n)
> {
> if (__n)
> {
> _Bit_pointer __q = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
> this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
> }
> else
> {
> this->_M_impl._M_end_of_storage = _Bit_pointer();
> this->_M_impl._M_start = iterator(0, 0);
> }
> this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
>
> }
>
> void
> _M_initialize_value(bool __x)
> {
> if (_Bit_type* __p = this->_M_impl._M_start._M_p)
> __builtin_memset(__p, __x ? ~0 : 0,
> (this->_M_impl._M_end_addr() - __p)
> * sizeof(_Bit_type));
> }
>
> void
> _M_reallocate(size_type __n);
>
>
> bool
> _M_shrink_to_fit();
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize(static_cast<size_type>(__n));
> _M_initialize_value(__x);
> }
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_initialize_range(__first, __last,
> std::__iterator_category(__first)); }
>
> template<typename _InputIterator>
> void
> _M_initialize_range(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
>
> template<typename _ForwardIterator>
> void
> _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> _M_initialize(__n);
> std::copy(__first, __last, this->_M_impl._M_start);
> }
># 1203 "/usr/include/c++/8/bits/stl_bvector.h" 3
> void
> _M_fill_assign(size_t __n, bool __x)
> {
> if (__n > size())
> {
> _M_initialize_value(__x);
> insert(end(), __n - size(), __x);
> }
> else
> {
> _M_erase_at_end(begin() + __n);
> _M_initialize_value(__x);
> }
> }
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur = begin();
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> insert(end(), __first, __last);
> }
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len < size())
> _M_erase_at_end(std::copy(__first, __last, begin()));
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> }
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> { _M_fill_insert(__pos, __n, __x); }
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_insert_range(__pos, __first, __last,
> std::__iterator_category(__first)); }
>
> void
> _M_fill_insert(iterator __position, size_type __n, bool __x);
>
> template<typename _InputIterator>
> void
> _M_insert_range(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<typename _ForwardIterator>
> void
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
> void
> _M_insert_aux(iterator __position, bool __x);
>
> size_type
> _M_check_len(size_type __n, const char* __s) const
> {
> if (max_size() - size() < __n)
> __throw_length_error((__s));
>
> const size_type __len = size() + std::max(size(), __n);
> return (__len < size() || __len > max_size()) ? max_size() : __len;
> }
>
> void
> _M_erase_at_end(iterator __pos)
> { this->_M_impl._M_finish = __pos; }
>
> iterator
> _M_erase(iterator __pos);
>
> iterator
> _M_erase(iterator __first, iterator __last);
> };
>
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _Alloc>
> struct hash<std::vector<bool, _Alloc>>
> : public __hash_base<size_t, std::vector<bool, _Alloc>>
> {
> size_t
> operator()(const std::vector<bool, _Alloc>&) const noexcept;
> };
>
>
>}
># 66 "/usr/include/c++/8/vector" 2 3
>
>
>
># 1 "/usr/include/c++/8/bits/vector.tcc" 1 3
># 59 "/usr/include/c++/8/bits/vector.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> reserve(size_type __n)
> {
> if (__n > this->max_size())
> __throw_length_error(("vector::reserve"));
> if (this->capacity() < __n)
> {
> const size_type __old_size = size();
> pointer __tmp = _M_allocate_and_copy(__n,
> std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
> std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
> ;
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = __tmp + __old_size;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
>
> typename vector<_Tp, _Alloc>::reference
>
>
>
> vector<_Tp, _Alloc>::
> emplace_back(_Args&&... __args)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> ;
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish;
> ;
> }
> else
> _M_realloc_insert(end(), std::forward<_Args>(__args)...);
>
> return back();
>
> }
>
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
>
> insert(const_iterator __position, const value_type& __x)
>
>
>
> {
> const size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> if (__position == end())
> {
> ;
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> __x);
> ++this->_M_impl._M_finish;
> ;
> }
> else
> {
>
> const auto __pos = begin() + (__position - cbegin());
>
>
> _Temporary_value __x_copy(this, __x);
> _M_insert_aux(__pos, std::move(__x_copy._M_val()));
>
>
>
> }
> else
>
> _M_realloc_insert(begin() + (__position - cbegin()), __x);
>
>
>
>
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> _M_erase(iterator __position)
> {
> if (__position + 1 != end())
> std::move(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
> ;
> return __position;
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> _M_erase(iterator __first, iterator __last)
> {
> if (__first != __last)
> {
> if (__last != end())
> std::move(__last, end(), __first);
> _M_erase_at_end(__first.base() + (end() - __last));
> }
> return __first;
> }
>
> template<typename _Tp, typename _Alloc>
> vector<_Tp, _Alloc>&
> vector<_Tp, _Alloc>::
> operator=(const vector<_Tp, _Alloc>& __x)
> {
> if (&__x != this)
> {
> ;
>
> if (_Alloc_traits::_S_propagate_on_copy_assign())
> {
> if (!_Alloc_traits::_S_always_equal()
> && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
> {
>
> this->clear();
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = nullptr;
> this->_M_impl._M_finish = nullptr;
> this->_M_impl._M_end_of_storage = nullptr;
> }
> std::__alloc_on_copy(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
> const size_type __xlen = __x.size();
> if (__xlen > capacity())
> {
> pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
> __x.end());
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
> }
> else if (size() >= __xlen)
> {
> std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
> end(), _M_get_Tp_allocator());
> }
> else
> {
> std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
> this->_M_impl._M_start);
> std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
> __x._M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
> }
> return *this;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_assign(size_t __n, const value_type& __val)
> {
> if (__n > capacity())
> {
> vector __tmp(__n, __val, _M_get_Tp_allocator());
> __tmp._M_impl._M_swap_data(this->_M_impl);
> }
> else if (__n > size())
> {
> std::fill(begin(), end(), __val);
> const size_type __add = __n - size();
> ;
> this->_M_impl._M_finish =
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __add, __val, _M_get_Tp_allocator());
> ;
> }
> else
> _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> pointer __cur(this->_M_impl._M_start);
> for (; __first != __last && __cur != this->_M_impl._M_finish;
> ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> _M_range_insert(end(), __first, __last,
> std::__iterator_category(__first));
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
>
> if (__len > capacity())
> {
> pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
> ;
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = this->_M_impl._M_start + __len;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
> }
> else if (size() >= __len)
> _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, this->_M_impl._M_start);
> const size_type __attribute__((__unused__)) __n = __len - size();
> ;
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> ;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> auto
> vector<_Tp, _Alloc>::
> _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
> {
> const auto __n = __position - cbegin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> if (__position == cend())
> {
> ;
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::move(__v));
> ++this->_M_impl._M_finish;
> ;
> }
> else
> _M_insert_aux(begin() + __n, std::move(__v));
> else
> _M_realloc_insert(begin() + __n, std::move(__v));
>
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> auto
> vector<_Tp, _Alloc>::
> _M_emplace_aux(const_iterator __position, _Args&&... __args)
> -> iterator
> {
> const auto __n = __position - cbegin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> if (__position == cend())
> {
> ;
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish;
> ;
> }
> else
> {
>
>
>
> _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
> _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
> }
> else
> _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);
>
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _Arg>
> void
> vector<_Tp, _Alloc>::
> _M_insert_aux(iterator __position, _Arg&& __arg)
>
>
>
>
>
>
> {
> ;
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::move(*(this->_M_impl._M_finish - 1)));
> ++this->_M_impl._M_finish;
> ;
>
>
>
> std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
>
> ;
>
>
>
> *__position = std::forward<_Arg>(__arg);
>
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> _M_realloc_insert(iterator __position, _Args&&... __args)
>
>
>
>
>
>
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector::_M_realloc_insert");
> pointer __old_start = this->_M_impl._M_start;
> pointer __old_finish = this->_M_impl._M_finish;
> const size_type __elems_before = __position - begin();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
>
>
>
>
>
> _Alloc_traits::construct(this->_M_impl,
> __new_start + __elems_before,
>
> std::forward<_Args>(__args)...);
>
>
>
> __new_finish = pointer();
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__old_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
>
> ++__new_finish;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), __old_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> if (!__new_finish)
> _Alloc_traits::destroy(this->_M_impl,
> __new_start + __elems_before);
> else
> std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> ;
> std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
> _M_deallocate(__old_start,
> this->_M_impl._M_end_of_storage - __old_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
> {
> if (__n != 0)
> {
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
>
>
>
> _Temporary_value __tmp(this, __x);
> value_type& __x_copy = __tmp._M_val();
>
> const size_type __elems_after = end() - __position;
> pointer __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> ;
> std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> ;
> std::move_backward(__position.base(), __old_finish - __n, __old_finish)
> ;
> std::fill(__position.base(), __position.base() + __n,
> __x_copy);
> }
> else
> {
> ;
> this->_M_impl._M_finish =
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - __elems_after,
> __x_copy,
> _M_get_Tp_allocator());
> ;
> std::__uninitialized_move_a(__position.base(), __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> ;
> std::fill(__position.base(), __old_finish, __x_copy);
> }
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_fill_insert");
> const size_type __elems_before = __position - begin();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
>
> std::__uninitialized_fill_n_a(__new_start + __elems_before,
> __n, __x,
> _M_get_Tp_allocator());
> __new_finish = pointer();
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
>
> __new_finish += __n;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> if (!__new_finish)
> std::_Destroy(__new_start + __elems_before,
> __new_start + __elems_before + __n,
> _M_get_Tp_allocator());
> else
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> ;
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_default_append(size_type __n)
> {
> if (__n != 0)
> {
> size_type __size = size();
> size_type __navail = size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish);
>
> if (__size > max_size() || __navail > max_size() - __size)
> __builtin_unreachable();
>
> if (__navail >= __n)
> {
> ;
> this->_M_impl._M_finish =
> std::__uninitialized_default_n_a(this->_M_impl._M_finish,
> __n, _M_get_Tp_allocator());
> ;
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_default_append");
> const size_type __old_size = __size;
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, this->_M_impl._M_finish,
> __new_start, _M_get_Tp_allocator());
> __new_finish =
> std::__uninitialized_default_n_a(__new_finish, __n,
> _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> ;
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
> template<typename _Tp, typename _Alloc>
> bool
> vector<_Tp, _Alloc>::
> _M_shrink_to_fit()
> {
> if (capacity() == size())
> return false;
> ;
> return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> if (__pos == end())
> {
> for (; __first != __last; ++__first)
> insert(end(), *__first);
> }
> else if (__first != __last)
> {
> vector __tmp(__first, __last, _M_get_Tp_allocator());
> insert(__pos,
> std::make_move_iterator(__tmp.begin()),
> std::make_move_iterator(__tmp.end()));
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> const size_type __n = std::distance(__first, __last);
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> const size_type __elems_after = end() - __position;
> pointer __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> ;
> std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> ;
> std::move_backward(__position.base(), __old_finish - __n, __old_finish)
> ;
> std::copy(__first, __last, __position);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elems_after);
> ;
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> ;
> std::__uninitialized_move_a(__position.base(),
> __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> ;
> std::copy(__first, __mid, __position);
> }
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_range_insert");
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
> __new_finish
> = std::__uninitialized_copy_a(__first, __last,
> __new_finish,
> _M_get_Tp_allocator());
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> ;
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
>
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_reallocate(size_type __n)
> {
> _Bit_pointer __q = this->_M_allocate(__n);
> iterator __start(std::__addressof(*__q), 0);
> iterator __finish(_M_copy_aligned(begin(), end(), __start));
> this->_M_deallocate();
> this->_M_impl._M_start = __start;
> this->_M_impl._M_finish = __finish;
> this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
> }
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, bool __x)
> {
> if (__n == 0)
> return;
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish + difference_type(__n));
> std::fill(__position, __position + difference_type(__n), __x);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector<bool>::_M_fill_insert");
> _Bit_pointer __q = this->_M_allocate(__len);
> iterator __start(std::__addressof(*__q), 0);
> iterator __i = _M_copy_aligned(begin(), __position, __start);
> std::fill(__i, __i + difference_type(__n), __x);
> iterator __finish = std::copy(__position, end(),
> __i + difference_type(__n));
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = __start;
> this->_M_impl._M_finish = __finish;
> }
> }
>
> template<typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<bool, _Alloc>::
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> size_type __n = std::distance(__first, __last);
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish
> + difference_type(__n));
> std::copy(__first, __last, __position);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector<bool>::_M_insert_range");
> _Bit_pointer __q = this->_M_allocate(__len);
> iterator __start(std::__addressof(*__q), 0);
> iterator __i = _M_copy_aligned(begin(), __position, __start);
> __i = std::copy(__first, __last, __i);
> iterator __finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = __start;
> this->_M_impl._M_finish = __finish;
> }
> }
> }
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_insert_aux(iterator __position, bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
> {
> std::copy_backward(__position, this->_M_impl._M_finish,
> this->_M_impl._M_finish + 1);
> *__position = __x;
> ++this->_M_impl._M_finish;
> }
> else
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
> _Bit_pointer __q = this->_M_allocate(__len);
> iterator __start(std::__addressof(*__q), 0);
> iterator __i = _M_copy_aligned(begin(), __position, __start);
> *__i++ = __x;
> iterator __finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = __start;
> this->_M_impl._M_finish = __finish;
> }
> }
>
> template<typename _Alloc>
> typename vector<bool, _Alloc>::iterator
> vector<bool, _Alloc>::
> _M_erase(iterator __position)
> {
> if (__position + 1 != end())
> std::copy(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> return __position;
> }
>
> template<typename _Alloc>
> typename vector<bool, _Alloc>::iterator
> vector<bool, _Alloc>::
> _M_erase(iterator __first, iterator __last)
> {
> if (__first != __last)
> _M_erase_at_end(std::copy(__last, end(), __first));
> return __first;
> }
>
>
> template<typename _Alloc>
> bool
> vector<bool, _Alloc>::
> _M_shrink_to_fit()
> {
> if (capacity() - size() < int(_S_word_bit))
> return false;
> try
> {
> _M_reallocate(size());
> return true;
> }
> catch(...)
> { return false; }
> }
>
>
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Alloc>
> size_t
> hash<std::vector<bool, _Alloc>>::
> operator()(const std::vector<bool, _Alloc>& __b) const noexcept
> {
> size_t __hash = 0;
> using std::_S_word_bit;
> using std::_Bit_type;
>
> const size_t __words = __b.size() / _S_word_bit;
> if (__words)
> {
> const size_t __clength = __words * sizeof(_Bit_type);
> __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
> }
>
> const size_t __extrabits = __b.size() % _S_word_bit;
> if (__extrabits)
> {
> _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
> __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
>
> const size_t __clength
> = (__extrabits + 8 - 1) / 8;
> if (__words)
> __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
> else
> __hash = std::_Hash_impl::hash(&__hiword, __clength);
> }
>
> return __hash;
> }
>
>
>}
># 70 "/usr/include/c++/8/vector" 2 3
># 32 "/usr/local/include/nghttp2/asio_http2.h" 2 3
># 1 "/usr/include/c++/8/functional" 1 3
># 46 "/usr/include/c++/8/functional" 3
> 
># 47 "/usr/include/c++/8/functional" 3
># 59 "/usr/include/c++/8/functional" 3
># 1 "/usr/include/c++/8/bits/std_function.h" 1 3
># 33 "/usr/include/c++/8/bits/std_function.h" 3
> 
># 34 "/usr/include/c++/8/bits/std_function.h" 3
># 47 "/usr/include/c++/8/bits/std_function.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> class bad_function_call : public std::exception
> {
> public:
> virtual ~bad_function_call() noexcept;
>
> const char* what() const noexcept;
> };
>
>
>
>
>
>
>
> template<typename _Tp>
> struct __is_location_invariant
> : is_trivially_copyable<_Tp>::type
> { };
>
> class _Undefined_class;
>
> union _Nocopy_types
> {
> void* _M_object;
> const void* _M_const_object;
> void (*_M_function_pointer)();
> void (_Undefined_class::*_M_member_pointer)();
> };
>
> union [[gnu::may_alias]] _Any_data
> {
> void* _M_access() { return &_M_pod_data[0]; }
> const void* _M_access() const { return &_M_pod_data[0]; }
>
> template<typename _Tp>
> _Tp&
> _M_access()
> { return *static_cast<_Tp*>(_M_access()); }
>
> template<typename _Tp>
> const _Tp&
> _M_access() const
> { return *static_cast<const _Tp*>(_M_access()); }
>
> _Nocopy_types _M_unused;
> char _M_pod_data[sizeof(_Nocopy_types)];
> };
>
> enum _Manager_operation
> {
> __get_type_info,
> __get_functor_ptr,
> __clone_functor,
> __destroy_functor
> };
>
>
>
> template<typename _Tp>
> struct _Simple_type_wrapper
> {
> _Simple_type_wrapper(_Tp __value) : __value(__value) { }
>
> _Tp __value;
> };
>
> template<typename _Tp>
> struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
> : __is_location_invariant<_Tp>
> { };
>
> template<typename _Signature>
> class function;
>
>
> class _Function_base
> {
> public:
> static const std::size_t _M_max_size = sizeof(_Nocopy_types);
> static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
>
> template<typename _Functor>
> class _Base_manager
> {
> protected:
> static const bool __stored_locally =
> (__is_location_invariant<_Functor>::value
> && sizeof(_Functor) <= _M_max_size
> && __alignof__(_Functor) <= _M_max_align
> && (_M_max_align % __alignof__(_Functor) == 0));
>
> typedef integral_constant<bool, __stored_locally> _Local_storage;
>
>
> static _Functor*
> _M_get_pointer(const _Any_data& __source)
> {
> const _Functor* __ptr =
> __stored_locally? std::__addressof(__source._M_access<_Functor>())
> : __source._M_access<_Functor*>();
> return const_cast<_Functor*>(__ptr);
> }
>
>
>
> static void
> _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
> {
> ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
> }
>
>
>
> static void
> _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
> {
> __dest._M_access<_Functor*>() =
> new _Functor(*__source._M_access<_Functor*>());
> }
>
>
>
> static void
> _M_destroy(_Any_data& __victim, true_type)
> {
> __victim._M_access<_Functor>().~_Functor();
> }
>
>
> static void
> _M_destroy(_Any_data& __victim, false_type)
> {
> delete __victim._M_access<_Functor*>();
> }
>
> public:
> static bool
> _M_manager(_Any_data& __dest, const _Any_data& __source,
> _Manager_operation __op)
> {
> switch (__op)
> {
>
> case __get_type_info:
> __dest._M_access<const type_info*>() = &typeid(_Functor);
> break;
>
> case __get_functor_ptr:
> __dest._M_access<_Functor*>() = _M_get_pointer(__source);
> break;
>
> case __clone_functor:
> _M_clone(__dest, __source, _Local_storage());
> break;
>
> case __destroy_functor:
> _M_destroy(__dest, _Local_storage());
> break;
> }
> return false;
> }
>
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f)
> { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
>
> template<typename _Signature>
> static bool
> _M_not_empty_function(const function<_Signature>& __f)
> { return static_cast<bool>(__f); }
>
> template<typename _Tp>
> static bool
> _M_not_empty_function(_Tp* __fp)
> { return __fp != nullptr; }
>
> template<typename _Class, typename _Tp>
> static bool
> _M_not_empty_function(_Tp _Class::* __mp)
> { return __mp != nullptr; }
>
> template<typename _Tp>
> static bool
> _M_not_empty_function(const _Tp&)
> { return true; }
>
> private:
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
> { ::new (__functor._M_access()) _Functor(std::move(__f)); }
>
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
> { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
> };
>
> _Function_base() : _M_manager(nullptr) { }
>
> ~_Function_base()
> {
> if (_M_manager)
> _M_manager(_M_functor, _M_functor, __destroy_functor);
> }
>
> bool _M_empty() const { return !_M_manager; }
>
> typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
> _Manager_operation);
>
> _Any_data _M_functor;
> _Manager_type _M_manager;
> };
>
> template<typename _Signature, typename _Functor>
> class _Function_handler;
>
> template<typename _Res, typename _Functor, typename... _ArgTypes>
> class _Function_handler<_Res(_ArgTypes...), _Functor>
> : public _Function_base::_Base_manager<_Functor>
> {
> typedef _Function_base::_Base_manager<_Functor> _Base;
>
> public:
> static _Res
> _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
> {
> return (*_Base::_M_get_pointer(__functor))(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Functor, typename... _ArgTypes>
> class _Function_handler<void(_ArgTypes...), _Functor>
> : public _Function_base::_Base_manager<_Functor>
> {
> typedef _Function_base::_Base_manager<_Functor> _Base;
>
> public:
> static void
> _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
> {
> (*_Base::_M_get_pointer(__functor))(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Class, typename _Member, typename _Res,
> typename... _ArgTypes>
> class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
> : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
> {
> typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
> _Base;
>
> public:
> static _Res
> _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
> {
> return std::__invoke(_Base::_M_get_pointer(__functor)->__value,
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Class, typename _Member, typename... _ArgTypes>
> class _Function_handler<void(_ArgTypes...), _Member _Class::*>
> : public _Function_base::_Base_manager<
> _Simple_type_wrapper< _Member _Class::* > >
> {
> typedef _Member _Class::* _Functor;
> typedef _Simple_type_wrapper<_Functor> _Wrapper;
> typedef _Function_base::_Base_manager<_Wrapper> _Base;
>
> public:
> static bool
> _M_manager(_Any_data& __dest, const _Any_data& __source,
> _Manager_operation __op)
> {
> switch (__op)
> {
>
> case __get_type_info:
> __dest._M_access<const type_info*>() = &typeid(_Functor);
> break;
>
> case __get_functor_ptr:
> __dest._M_access<_Functor*>() =
> &_Base::_M_get_pointer(__source)->__value;
> break;
>
> default:
> _Base::_M_manager(__dest, __source, __op);
> }
> return false;
> }
>
> static void
> _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
> {
> std::__invoke(_Base::_M_get_pointer(__functor)->__value,
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _From, typename _To>
> using __check_func_return_type
> = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
>
>
>
>
>
>
>
> template<typename _Res, typename... _ArgTypes>
> class function<_Res(_ArgTypes...)>
> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
> private _Function_base
> {
> template<typename _Func,
> typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
> struct _Callable : __check_func_return_type<_Res2, _Res> { };
>
>
>
> template<typename _Tp>
> struct _Callable<function, _Tp> : false_type { };
>
> template<typename _Cond, typename _Tp>
> using _Requires = typename enable_if<_Cond::value, _Tp>::type;
>
> public:
> typedef _Res result_type;
>
>
>
>
>
>
>
> function() noexcept
> : _Function_base() { }
>
>
>
>
>
> function(nullptr_t) noexcept
> : _Function_base() { }
># 413 "/usr/include/c++/8/bits/std_function.h" 3
> function(const function& __x);
># 422 "/usr/include/c++/8/bits/std_function.h" 3
> function(function&& __x) noexcept : _Function_base()
> {
> __x.swap(*this);
> }
># 443 "/usr/include/c++/8/bits/std_function.h" 3
> template<typename _Functor,
> typename = _Requires<__not_<is_same<_Functor, function>>, void>,
> typename = _Requires<_Callable<_Functor>, void>>
> function(_Functor);
># 460 "/usr/include/c++/8/bits/std_function.h" 3
> function&
> operator=(const function& __x)
> {
> function(__x).swap(*this);
> return *this;
> }
># 478 "/usr/include/c++/8/bits/std_function.h" 3
> function&
> operator=(function&& __x) noexcept
> {
> function(std::move(__x)).swap(*this);
> return *this;
> }
># 492 "/usr/include/c++/8/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;
> }
># 520 "/usr/include/c++/8/bits/std_function.h" 3
> template<typename _Functor>
> _Requires<_Callable<typename decay<_Functor>::type>, function&>
> operator=(_Functor&& __f)
> {
> function(std::forward<_Functor>(__f)).swap(*this);
> return *this;
> }
>
>
> template<typename _Functor>
> function&
> operator=(reference_wrapper<_Functor> __f) noexcept
> {
> function(__f).swap(*this);
> return *this;
> }
># 546 "/usr/include/c++/8/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);
> }
># 563 "/usr/include/c++/8/bits/std_function.h" 3
> explicit operator bool() const noexcept
> { return !_M_empty(); }
># 576 "/usr/include/c++/8/bits/std_function.h" 3
> _Res operator()(_ArgTypes... __args) const;
># 589 "/usr/include/c++/8/bits/std_function.h" 3
> const type_info& target_type() const noexcept;
># 602 "/usr/include/c++/8/bits/std_function.h" 3
> template<typename _Functor> _Functor* target() noexcept;
>
> template<typename _Functor> const _Functor* target() const noexcept;
>
>
>
> private:
> using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
> _Invoker_type _M_invoker;
> };
>
>
> template<typename>
> struct __function_guide_helper
> { };
>
> template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
> struct __function_guide_helper<
> _Res (_Tp::*) (_Args...) noexcept(_Nx)
> >
> { using type = _Res(_Args...); };
>
> template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
> struct __function_guide_helper<
> _Res (_Tp::*) (_Args...) & noexcept(_Nx)
> >
> { using type = _Res(_Args...); };
>
> template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
> struct __function_guide_helper<
> _Res (_Tp::*) (_Args...) const noexcept(_Nx)
> >
> { using type = _Res(_Args...); };
>
> template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
> struct __function_guide_helper<
> _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
> >
> { using type = _Res(_Args...); };
>
> template<typename _Res, typename... _ArgTypes>
> function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;
>
> template<typename _Functor, typename _Signature = typename
> __function_guide_helper<decltype(&_Functor::operator())>::type>
> function(_Functor) -> function<_Signature>;
>
>
>
> template<typename _Res, typename... _ArgTypes>
> function<_Res(_ArgTypes...)>::
> function(const function& __x)
> : _Function_base()
> {
> if (static_cast<bool>(__x))
> {
> __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
> _M_invoker = __x._M_invoker;
> _M_manager = __x._M_manager;
> }
> }
>
> template<typename _Res, typename... _ArgTypes>
> template<typename _Functor, typename, typename>
> function<_Res(_ArgTypes...)>::
> function(_Functor __f)
> : _Function_base()
> {
> typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
>
> if (_My_handler::_M_not_empty_function(__f))
> {
> _My_handler::_M_init_functor(_M_functor, std::move(__f));
> _M_invoker = &_My_handler::_M_invoke;
> _M_manager = &_My_handler::_M_manager;
> }
> }
>
> template<typename _Res, typename... _ArgTypes>
> _Res
> function<_Res(_ArgTypes...)>::
> operator()(_ArgTypes... __args) const
> {
> if (_M_empty())
> __throw_bad_function_call();
> return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
> }
>
>
> template<typename _Res, typename... _ArgTypes>
> const type_info&
> function<_Res(_ArgTypes...)>::
> target_type() const noexcept
> {
> if (_M_manager)
> {
> _Any_data __typeinfo_result;
> _M_manager(__typeinfo_result, _M_functor, __get_type_info);
> return *__typeinfo_result._M_access<const type_info*>();
> }
> else
> return typeid(void);
> }
>
> template<typename _Res, typename... _ArgTypes>
> template<typename _Functor>
> _Functor*
> function<_Res(_ArgTypes...)>::
> target() noexcept
> {
> const function* __const_this = this;
> const _Functor* __func = __const_this->template target<_Functor>();
> return const_cast<_Functor*>(__func);
> }
>
> template<typename _Res, typename... _ArgTypes>
> template<typename _Functor>
> const _Functor*
> function<_Res(_ArgTypes...)>::
> target() const noexcept
> {
> if (typeid(_Functor) == target_type() && _M_manager)
> {
> _Any_data __ptr;
> _M_manager(__ptr, _M_functor, __get_functor_ptr);
> return __ptr._M_access<const _Functor*>();
> }
> else
> return nullptr;
> }
># 743 "/usr/include/c++/8/bits/std_function.h" 3
> template<typename _Res, typename... _Args>
> inline bool
> operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
> { return !static_cast<bool>(__f); }
>
>
> template<typename _Res, typename... _Args>
> inline bool
> operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
> { return !static_cast<bool>(__f); }
># 761 "/usr/include/c++/8/bits/std_function.h" 3
> template<typename _Res, typename... _Args>
> inline bool
> operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
> { return static_cast<bool>(__f); }
>
>
> template<typename _Res, typename... _Args>
> inline bool
> operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
> { return static_cast<bool>(__f); }
># 782 "/usr/include/c++/8/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); }
>
>
>}
># 60 "/usr/include/c++/8/functional" 2 3
>
># 1 "/usr/include/c++/8/unordered_map" 1 3
># 32 "/usr/include/c++/8/unordered_map" 3
> 
># 33 "/usr/include/c++/8/unordered_map" 3
># 46 "/usr/include/c++/8/unordered_map" 3
># 1 "/usr/include/c++/8/bits/hashtable.h" 1 3
># 33 "/usr/include/c++/8/bits/hashtable.h" 3
> 
># 34 "/usr/include/c++/8/bits/hashtable.h" 3
>
># 1 "/usr/include/c++/8/bits/hashtable_policy.h" 1 3
># 38 "/usr/include/c++/8/bits/hashtable_policy.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> class _Hashtable;
>
>namespace __detail
>{
>
>
>
>
>
> template<typename _Key, typename _Value,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _Traits>
> struct _Hashtable_base;
>
>
>
> template<class _Iterator>
> inline typename std::iterator_traits<_Iterator>::difference_type
> __distance_fw(_Iterator __first, _Iterator __last,
> std::input_iterator_tag)
> { return __first != __last ? 1 : 0; }
>
> template<class _Iterator>
> inline typename std::iterator_traits<_Iterator>::difference_type
> __distance_fw(_Iterator __first, _Iterator __last,
> std::forward_iterator_tag)
> { return std::distance(__first, __last); }
>
> template<class _Iterator>
> inline typename std::iterator_traits<_Iterator>::difference_type
> __distance_fw(_Iterator __first, _Iterator __last)
> { return __distance_fw(__first, __last,
> std::__iterator_category(__first)); }
>
> struct _Identity
> {
> template<typename _Tp>
> _Tp&&
> operator()(_Tp&& __x) const
> { return std::forward<_Tp>(__x); }
> };
>
> struct _Select1st
> {
> template<typename _Tp>
> auto
> operator()(_Tp&& __x) const
> -> decltype(std::get<0>(std::forward<_Tp>(__x)))
> { return std::get<0>(std::forward<_Tp>(__x)); }
> };
>
> template<typename _NodeAlloc>
> struct _Hashtable_alloc;
>
>
>
> template<typename _NodeAlloc>
> struct _ReuseOrAllocNode
> {
> private:
> using __node_alloc_type = _NodeAlloc;
> using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
> using __node_alloc_traits =
> typename __hashtable_alloc::__node_alloc_traits;
> using __node_type = typename __hashtable_alloc::__node_type;
>
> public:
> _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h)
> : _M_nodes(__nodes), _M_h(__h) { }
> _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;
>
> ~_ReuseOrAllocNode()
> { _M_h._M_deallocate_nodes(_M_nodes); }
>
> template<typename _Arg>
> __node_type*
> operator()(_Arg&& __arg) const
> {
> if (_M_nodes)
> {
> __node_type* __node = _M_nodes;
> _M_nodes = _M_nodes->_M_next();
> __node->_M_nxt = nullptr;
> auto& __a = _M_h._M_node_allocator();
> __node_alloc_traits::destroy(__a, __node->_M_valptr());
> try
> {
> __node_alloc_traits::construct(__a, __node->_M_valptr(),
> std::forward<_Arg>(__arg));
> }
> catch(...)
> {
> __node->~__node_type();
> __node_alloc_traits::deallocate(__a, __node, 1);
> throw;
> }
> return __node;
> }
> return _M_h._M_allocate_node(std::forward<_Arg>(__arg));
> }
>
> private:
> mutable __node_type* _M_nodes;
> __hashtable_alloc& _M_h;
> };
>
>
>
> template<typename _NodeAlloc>
> struct _AllocNode
> {
> private:
> using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
> using __node_type = typename __hashtable_alloc::__node_type;
>
> public:
> _AllocNode(__hashtable_alloc& __h)
> : _M_h(__h) { }
>
> template<typename _Arg>
> __node_type*
> operator()(_Arg&& __arg) const
> { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); }
>
> private:
> __hashtable_alloc& _M_h;
> };
># 199 "/usr/include/c++/8/bits/hashtable_policy.h" 3
> template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
> struct _Hashtable_traits
> {
> using __hash_cached = __bool_constant<_Cache_hash_code>;
> using __constant_iterators = __bool_constant<_Constant_iterators>;
> using __unique_keys = __bool_constant<_Unique_keys>;
> };
># 215 "/usr/include/c++/8/bits/hashtable_policy.h" 3
> struct _Hash_node_base
> {
> _Hash_node_base* _M_nxt;
>
> _Hash_node_base() noexcept : _M_nxt() { }
>
> _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
> };
>
>
>
>
>
>
> template<typename _Value>
> struct _Hash_node_value_base : _Hash_node_base
> {
> typedef _Value value_type;
>
> __gnu_cxx::__aligned_buffer<_Value> _M_storage;
>
> _Value*
> _M_valptr() noexcept
> { return _M_storage._M_ptr(); }
>
> const _Value*
> _M_valptr() const noexcept
> { return _M_storage._M_ptr(); }
>
> _Value&
> _M_v() noexcept
> { return *_M_valptr(); }
>
> const _Value&
> _M_v() const noexcept
> { return *_M_valptr(); }
> };
>
>
>
>
> template<typename _Value, bool _Cache_hash_code>
> struct _Hash_node;
>
>
>
>
>
>
> template<typename _Value>
> struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
> {
> std::size_t _M_hash_code;
>
> _Hash_node*
> _M_next() const noexcept
> { return static_cast<_Hash_node*>(this->_M_nxt); }
> };
>
>
>
>
>
>
> template<typename _Value>
> struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
> {
> _Hash_node*
> _M_next() const noexcept
> { return static_cast<_Hash_node*>(this->_M_nxt); }
> };
>
>
> template<typename _Value, bool _Cache_hash_code>
> struct _Node_iterator_base
> {
> using __node_type = _Hash_node<_Value, _Cache_hash_code>;
>
> __node_type* _M_cur;
>
> _Node_iterator_base(__node_type* __p) noexcept
> : _M_cur(__p) { }
>
> void
> _M_incr() noexcept
> { _M_cur = _M_cur->_M_next(); }
> };
>
> template<typename _Value, bool _Cache_hash_code>
> inline bool
> operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
> const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
> noexcept
> { return __x._M_cur == __y._M_cur; }
>
> template<typename _Value, bool _Cache_hash_code>
> inline bool
> operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
> const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
> noexcept
> { return __x._M_cur != __y._M_cur; }
>
>
> template<typename _Value, bool __constant_iterators, bool __cache>
> struct _Node_iterator
> : public _Node_iterator_base<_Value, __cache>
> {
> private:
> using __base_type = _Node_iterator_base<_Value, __cache>;
> using __node_type = typename __base_type::__node_type;
>
> public:
> typedef _Value value_type;
> typedef std::ptrdiff_t difference_type;
> typedef std::forward_iterator_tag iterator_category;
>
> using pointer = typename std::conditional<__constant_iterators,
> const _Value*, _Value*>::type;
>
> using reference = typename std::conditional<__constant_iterators,
> const _Value&, _Value&>::type;
>
> _Node_iterator() noexcept
> : __base_type(0) { }
>
> explicit
> _Node_iterator(__node_type* __p) noexcept
> : __base_type(__p) { }
>
> reference
> operator*() const noexcept
> { return this->_M_cur->_M_v(); }
>
> pointer
> operator->() const noexcept
> { return this->_M_cur->_M_valptr(); }
>
> _Node_iterator&
> operator++() noexcept
> {
> this->_M_incr();
> return *this;
> }
>
> _Node_iterator
> operator++(int) noexcept
> {
> _Node_iterator __tmp(*this);
> this->_M_incr();
> return __tmp;
> }
> };
>
>
> template<typename _Value, bool __constant_iterators, bool __cache>
> struct _Node_const_iterator
> : public _Node_iterator_base<_Value, __cache>
> {
> private:
> using __base_type = _Node_iterator_base<_Value, __cache>;
> using __node_type = typename __base_type::__node_type;
>
> public:
> typedef _Value value_type;
> typedef std::ptrdiff_t difference_type;
> typedef std::forward_iterator_tag iterator_category;
>
> typedef const _Value* pointer;
> typedef const _Value& reference;
>
> _Node_const_iterator() noexcept
> : __base_type(0) { }
>
> explicit
> _Node_const_iterator(__node_type* __p) noexcept
> : __base_type(__p) { }
>
> _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
> __cache>& __x) noexcept
> : __base_type(__x._M_cur) { }
>
> reference
> operator*() const noexcept
> { return this->_M_cur->_M_v(); }
>
> pointer
> operator->() const noexcept
> { return this->_M_cur->_M_valptr(); }
>
> _Node_const_iterator&
> operator++() noexcept
> {
> this->_M_incr();
> return *this;
> }
>
> _Node_const_iterator
> operator++(int) noexcept
> {
> _Node_const_iterator __tmp(*this);
> this->_M_incr();
> return __tmp;
> }
> };
>
>
>
>
>
>
> struct _Mod_range_hashing
> {
> typedef std::size_t first_argument_type;
> typedef std::size_t second_argument_type;
> typedef std::size_t result_type;
>
> result_type
> operator()(first_argument_type __num,
> second_argument_type __den) const noexcept
> { return __num % __den; }
> };
>
>
>
>
>
>
> struct _Default_ranged_hash { };
>
>
>
> struct _Prime_rehash_policy
> {
> using __has_load_factor = std::true_type;
>
> _Prime_rehash_policy(float __z = 1.0) noexcept
> : _M_max_load_factor(__z), _M_next_resize(0) { }
>
> float
> max_load_factor() const noexcept
> { return _M_max_load_factor; }
>
>
> std::size_t
> _M_next_bkt(std::size_t __n) const;
>
>
> std::size_t
> _M_bkt_for_elements(std::size_t __n) const
> { return __builtin_ceil(__n / (long double)_M_max_load_factor); }
>
>
>
>
>
> std::pair<bool, std::size_t>
> _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
> std::size_t __n_ins) const;
>
> typedef std::size_t _State;
>
> _State
> _M_state() const
> { return _M_next_resize; }
>
> void
> _M_reset() noexcept
> { _M_next_resize = 0; }
>
> void
> _M_reset(_State __state)
> { _M_next_resize = __state; }
>
> static const std::size_t _S_growth_factor = 2;
>
> float _M_max_load_factor;
> mutable std::size_t _M_next_resize;
> };
>
>
> struct _Mask_range_hashing
> {
> typedef std::size_t first_argument_type;
> typedef std::size_t second_argument_type;
> typedef std::size_t result_type;
>
> result_type
> operator()(first_argument_type __num,
> second_argument_type __den) const noexcept
> { return __num & (__den - 1); }
> };
>
>
> constexpr
> inline std::size_t
> __clp2(std::size_t __n) noexcept
> {
>
> std::uint_fast64_t __x = __n;
>
>
>
>
> __x = __x - 1;
> __x = __x | (__x >> 1);
> __x = __x | (__x >> 2);
> __x = __x | (__x >> 4);
> __x = __x | (__x >> 8);
> __x = __x | (__x >>16);
>
> __x = __x | (__x >>32);
>
> return __x + 1;
> }
>
>
>
> struct _Power2_rehash_policy
> {
> using __has_load_factor = std::true_type;
>
> _Power2_rehash_policy(float __z = 1.0) noexcept
> : _M_max_load_factor(__z), _M_next_resize(0) { }
>
> float
> max_load_factor() const noexcept
> { return _M_max_load_factor; }
>
>
>
> std::size_t
> _M_next_bkt(std::size_t __n) noexcept
> {
> const auto __max_width = std::min<size_t>(sizeof(size_t), 8);
> const auto __max_bkt = size_t(1) << (__max_width * 8 - 1);
> std::size_t __res = __clp2(__n);
>
> if (__res == __n)
> __res <<= 1;
>
> if (__res == 0)
> __res = __max_bkt;
>
> if (__res == __max_bkt)
>
>
>
> _M_next_resize = std::size_t(-1);
> else
> _M_next_resize
> = __builtin_ceil(__res * (long double)_M_max_load_factor);
>
> return __res;
> }
>
>
> std::size_t
> _M_bkt_for_elements(std::size_t __n) const noexcept
> { return __builtin_ceil(__n / (long double)_M_max_load_factor); }
>
>
>
>
>
> std::pair<bool, std::size_t>
> _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
> std::size_t __n_ins) noexcept
> {
> if (__n_elt + __n_ins >= _M_next_resize)
> {
> long double __min_bkts = (__n_elt + __n_ins)
> / (long double)_M_max_load_factor;
> if (__min_bkts >= __n_bkt)
> return std::make_pair(true,
> _M_next_bkt(std::max<std::size_t>(__builtin_floor(__min_bkts) + 1,
> __n_bkt * _S_growth_factor)));
>
> _M_next_resize
> = __builtin_floor(__n_bkt * (long double)_M_max_load_factor);
> return std::make_pair(false, 0);
> }
> else
> return std::make_pair(false, 0);
> }
>
> typedef std::size_t _State;
>
> _State
> _M_state() const noexcept
> { return _M_next_resize; }
>
> void
> _M_reset() noexcept
> { _M_next_resize = 0; }
>
> void
> _M_reset(_State __state) noexcept
> { _M_next_resize = __state; }
>
> static const std::size_t _S_growth_factor = 2;
>
> float _M_max_load_factor;
> std::size_t _M_next_resize;
> };
># 638 "/usr/include/c++/8/bits/hashtable_policy.h" 3
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits,
> bool _Unique_keys = _Traits::__unique_keys::value>
> struct _Map_base { };
>
>
> template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
> {
> using mapped_type = typename std::tuple_element<1, _Pair>::type;
> };
>
>
> template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
> {
> private:
> using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair,
> _Select1st,
> _Equal, _H1, _H2, _Hash,
> _Traits>;
>
> using __hashtable = _Hashtable<_Key, _Pair, _Alloc,
> _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>;
>
> using __hash_code = typename __hashtable_base::__hash_code;
> using __node_type = typename __hashtable_base::__node_type;
>
> public:
> using key_type = typename __hashtable_base::key_type;
> using iterator = typename __hashtable_base::iterator;
> using mapped_type = typename std::tuple_element<1, _Pair>::type;
>
> mapped_type&
> operator[](const key_type& __k);
>
> mapped_type&
> operator[](key_type&& __k);
>
>
>
> mapped_type&
> at(const key_type& __k);
>
> const mapped_type&
> at(const key_type& __k) const;
> };
>
> template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> auto
> _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
> operator[](const key_type& __k)
> -> mapped_type&
> {
> __hashtable* __h = static_cast<__hashtable*>(this);
> __hash_code __code = __h->_M_hash_code(__k);
> std::size_t __n = __h->_M_bucket_index(__k, __code);
> __node_type* __p = __h->_M_find_node(__n, __k, __code);
>
> if (!__p)
> {
> __p = __h->_M_allocate_node(std::piecewise_construct,
> std::tuple<const key_type&>(__k),
> std::tuple<>());
> return __h->_M_insert_unique_node(__n, __code, __p)->second;
> }
>
> return __p->_M_v().second;
> }
>
> template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> auto
> _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
> operator[](key_type&& __k)
> -> mapped_type&
> {
> __hashtable* __h = static_cast<__hashtable*>(this);
> __hash_code __code = __h->_M_hash_code(__k);
> std::size_t __n = __h->_M_bucket_index(__k, __code);
> __node_type* __p = __h->_M_find_node(__n, __k, __code);
>
> if (!__p)
> {
> __p = __h->_M_allocate_node(std::piecewise_construct,
> std::forward_as_tuple(std::move(__k)),
> std::tuple<>());
> return __h->_M_insert_unique_node(__n, __code, __p)->second;
> }
>
> return __p->_M_v().second;
> }
>
> template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> auto
> _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
> at(const key_type& __k)
> -> mapped_type&
> {
> __hashtable* __h = static_cast<__hashtable*>(this);
> __hash_code __code = __h->_M_hash_code(__k);
> std::size_t __n = __h->_M_bucket_index(__k, __code);
> __node_type* __p = __h->_M_find_node(__n, __k, __code);
>
> if (!__p)
> __throw_out_of_range(("_Map_base::at"));
> return __p->_M_v().second;
> }
>
> template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> auto
> _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
> at(const key_type& __k) const
> -> const mapped_type&
> {
> const __hashtable* __h = static_cast<const __hashtable*>(this);
> __hash_code __code = __h->_M_hash_code(__k);
> std::size_t __n = __h->_M_bucket_index(__k, __code);
> __node_type* __p = __h->_M_find_node(__n, __k, __code);
>
> if (!__p)
> __throw_out_of_range(("_Map_base::at"));
> return __p->_M_v().second;
> }
>
>
>
>
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Insert_base
> {
> protected:
> using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
>
> using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _Traits>;
>
> using value_type = typename __hashtable_base::value_type;
> using iterator = typename __hashtable_base::iterator;
> using const_iterator = typename __hashtable_base::const_iterator;
> using size_type = typename __hashtable_base::size_type;
>
> using __unique_keys = typename __hashtable_base::__unique_keys;
> using __ireturn_type = typename __hashtable_base::__ireturn_type;
> using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>;
> using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
> using __node_gen_type = _AllocNode<__node_alloc_type>;
>
> __hashtable&
> _M_conjure_hashtable()
> { return *(static_cast<__hashtable*>(this)); }
>
> template<typename _InputIterator, typename _NodeGetter>
> void
> _M_insert_range(_InputIterator __first, _InputIterator __last,
> const _NodeGetter&, true_type);
>
> template<typename _InputIterator, typename _NodeGetter>
> void
> _M_insert_range(_InputIterator __first, _InputIterator __last,
> const _NodeGetter&, false_type);
>
> public:
> __ireturn_type
> insert(const value_type& __v)
> {
> __hashtable& __h = _M_conjure_hashtable();
> __node_gen_type __node_gen(__h);
> return __h._M_insert(__v, __node_gen, __unique_keys());
> }
>
> iterator
> insert(const_iterator __hint, const value_type& __v)
> {
> __hashtable& __h = _M_conjure_hashtable();
> __node_gen_type __node_gen(__h);
> return __h._M_insert(__hint, __v, __node_gen, __unique_keys());
> }
>
> void
> insert(initializer_list<value_type> __l)
> { this->insert(__l.begin(), __l.end()); }
>
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> {
> __hashtable& __h = _M_conjure_hashtable();
> __node_gen_type __node_gen(__h);
> return _M_insert_range(__first, __last, __node_gen, __unique_keys());
> }
> };
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> template<typename _InputIterator, typename _NodeGetter>
> void
> _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>::
> _M_insert_range(_InputIterator __first, _InputIterator __last,
> const _NodeGetter& __node_gen, true_type)
> {
> size_type __n_elt = __detail::__distance_fw(__first, __last);
> if (__n_elt == 0)
> return;
>
> __hashtable& __h = _M_conjure_hashtable();
> for (; __first != __last; ++__first)
> {
> if (__h._M_insert(*__first, __node_gen, __unique_keys(),
> __n_elt).second)
> __n_elt = 1;
> else if (__n_elt != 1)
> --__n_elt;
> }
> }
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> template<typename _InputIterator, typename _NodeGetter>
> void
> _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>::
> _M_insert_range(_InputIterator __first, _InputIterator __last,
> const _NodeGetter& __node_gen, false_type)
> {
> using __rehash_type = typename __hashtable::__rehash_type;
> using __rehash_state = typename __hashtable::__rehash_state;
> using pair_type = std::pair<bool, std::size_t>;
>
> size_type __n_elt = __detail::__distance_fw(__first, __last);
> if (__n_elt == 0)
> return;
>
> __hashtable& __h = _M_conjure_hashtable();
> __rehash_type& __rehash = __h._M_rehash_policy;
> const __rehash_state& __saved_state = __rehash._M_state();
> pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count,
> __h._M_element_count,
> __n_elt);
>
> if (__do_rehash.first)
> __h._M_rehash(__do_rehash.second, __saved_state);
>
> for (; __first != __last; ++__first)
> __h._M_insert(*__first, __node_gen, __unique_keys());
> }
>
>
>
>
>
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits,
> bool _Constant_iterators = _Traits::__constant_iterators::value>
> struct _Insert;
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits, true>
> : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>
> {
> using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
>
> using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _Traits>;
>
> using value_type = typename __base_type::value_type;
> using iterator = typename __base_type::iterator;
> using const_iterator = typename __base_type::const_iterator;
>
> using __unique_keys = typename __base_type::__unique_keys;
> using __ireturn_type = typename __hashtable_base::__ireturn_type;
> using __hashtable = typename __base_type::__hashtable;
> using __node_gen_type = typename __base_type::__node_gen_type;
>
> using __base_type::insert;
>
> __ireturn_type
> insert(value_type&& __v)
> {
> __hashtable& __h = this->_M_conjure_hashtable();
> __node_gen_type __node_gen(__h);
> return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
> }
>
> iterator
> insert(const_iterator __hint, value_type&& __v)
> {
> __hashtable& __h = this->_M_conjure_hashtable();
> __node_gen_type __node_gen(__h);
> return __h._M_insert(__hint, std::move(__v), __node_gen,
> __unique_keys());
> }
> };
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits, false>
> : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>
> {
> using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
> using value_type = typename __base_type::value_type;
> using iterator = typename __base_type::iterator;
> using const_iterator = typename __base_type::const_iterator;
>
> using __unique_keys = typename __base_type::__unique_keys;
> using __hashtable = typename __base_type::__hashtable;
> using __ireturn_type = typename __base_type::__ireturn_type;
>
> using __base_type::insert;
>
> template<typename _Pair>
> using __is_cons = std::is_constructible<value_type, _Pair&&>;
>
> template<typename _Pair>
> using _IFcons = std::enable_if<__is_cons<_Pair>::value>;
>
> template<typename _Pair>
> using _IFconsp = typename _IFcons<_Pair>::type;
>
> template<typename _Pair, typename = _IFconsp<_Pair>>
> __ireturn_type
> insert(_Pair&& __v)
> {
> __hashtable& __h = this->_M_conjure_hashtable();
> return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v));
> }
>
> template<typename _Pair, typename = _IFconsp<_Pair>>
> iterator
> insert(const_iterator __hint, _Pair&& __v)
> {
> __hashtable& __h = this->_M_conjure_hashtable();
> return __h._M_emplace(__hint, __unique_keys(),
> std::forward<_Pair>(__v));
> }
> };
>
> template<typename _Policy>
> using __has_load_factor = typename _Policy::__has_load_factor;
>
>
>
>
>
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits,
> typename =
> __detected_or_t<std::false_type, __has_load_factor, _RehashPolicy>>
> struct _Rehash_base;
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits,
> std::false_type>
> {
> };
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits,
> std::true_type>
> {
> using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
>
> float
> max_load_factor() const noexcept
> {
> const __hashtable* __this = static_cast<const __hashtable*>(this);
> return __this->__rehash_policy().max_load_factor();
> }
>
> void
> max_load_factor(float __z)
> {
> __hashtable* __this = static_cast<__hashtable*>(this);
> __this->__rehash_policy(_RehashPolicy(__z));
> }
>
> void
> reserve(std::size_t __n)
> {
> __hashtable* __this = static_cast<__hashtable*>(this);
> __this->rehash(__builtin_ceil(__n / max_load_factor()));
> }
> };
>
>
>
>
>
>
>
> template<int _Nm, typename _Tp,
> bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
> struct _Hashtable_ebo_helper;
>
>
> template<int _Nm, typename _Tp>
> struct _Hashtable_ebo_helper<_Nm, _Tp, true>
> : private _Tp
> {
> _Hashtable_ebo_helper() = default;
>
> template<typename _OtherTp>
> _Hashtable_ebo_helper(_OtherTp&& __tp)
> : _Tp(std::forward<_OtherTp>(__tp))
> { }
>
> static const _Tp&
> _S_cget(const _Hashtable_ebo_helper& __eboh)
> { return static_cast<const _Tp&>(__eboh); }
>
> static _Tp&
> _S_get(_Hashtable_ebo_helper& __eboh)
> { return static_cast<_Tp&>(__eboh); }
> };
>
>
> template<int _Nm, typename _Tp>
> struct _Hashtable_ebo_helper<_Nm, _Tp, false>
> {
> _Hashtable_ebo_helper() = default;
>
> template<typename _OtherTp>
> _Hashtable_ebo_helper(_OtherTp&& __tp)
> : _M_tp(std::forward<_OtherTp>(__tp))
> { }
>
> static const _Tp&
> _S_cget(const _Hashtable_ebo_helper& __eboh)
> { return __eboh._M_tp; }
>
> static _Tp&
> _S_get(_Hashtable_ebo_helper& __eboh)
> { return __eboh._M_tp; }
>
> private:
> _Tp _M_tp;
> };
>
>
>
>
>
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash,
> bool __cache_hash_code>
> struct _Local_iterator_base;
># 1176 "/usr/include/c++/8/bits/hashtable_policy.h" 3
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash,
> bool __cache_hash_code>
> struct _Hash_code_base;
>
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash>
> struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
> : private _Hashtable_ebo_helper<0, _ExtractKey>,
> private _Hashtable_ebo_helper<1, _Hash>
> {
> private:
> using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
> using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;
>
> protected:
> typedef void* __hash_code;
> typedef _Hash_node<_Value, false> __node_type;
>
>
>
> _Hash_code_base() = default;
>
> _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&,
> const _Hash& __h)
> : __ebo_extract_key(__ex), __ebo_hash(__h) { }
>
> __hash_code
> _M_hash_code(const _Key& __key) const
> { return 0; }
>
> std::size_t
> _M_bucket_index(const _Key& __k, __hash_code, std::size_t __n) const
> { return _M_ranged_hash()(__k, __n); }
>
> std::size_t
> _M_bucket_index(const __node_type* __p, std::size_t __n) const
> noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(),
> (std::size_t)0)) )
> { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __n); }
>
> void
> _M_store_code(__node_type*, __hash_code) const
> { }
>
> void
> _M_copy_code(__node_type*, const __node_type*) const
> { }
>
> void
> _M_swap(_Hash_code_base& __x)
> {
> std::swap(_M_extract(), __x._M_extract());
> std::swap(_M_ranged_hash(), __x._M_ranged_hash());
> }
>
> const _ExtractKey&
> _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
>
> _ExtractKey&
> _M_extract() { return __ebo_extract_key::_S_get(*this); }
>
> const _Hash&
> _M_ranged_hash() const { return __ebo_hash::_S_cget(*this); }
>
> _Hash&
> _M_ranged_hash() { return __ebo_hash::_S_get(*this); }
> };
>
>
>
>
>
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash>
> struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;
>
>
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2>
> struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
> _Default_ranged_hash, false>
> : private _Hashtable_ebo_helper<0, _ExtractKey>,
> private _Hashtable_ebo_helper<1, _H1>,
> private _Hashtable_ebo_helper<2, _H2>
> {
> private:
> using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
> using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
> using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
>
>
> friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
> _Default_ranged_hash, false>;
>
> public:
> typedef _H1 hasher;
>
> hasher
> hash_function() const
> { return _M_h1(); }
>
> protected:
> typedef std::size_t __hash_code;
> typedef _Hash_node<_Value, false> __node_type;
>
>
>
> _Hash_code_base() = default;
>
> _Hash_code_base(const _ExtractKey& __ex,
> const _H1& __h1, const _H2& __h2,
> const _Default_ranged_hash&)
> : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
>
> __hash_code
> _M_hash_code(const _Key& __k) const
> { return _M_h1()(__k); }
>
> std::size_t
> _M_bucket_index(const _Key&, __hash_code __c, std::size_t __n) const
> { return _M_h2()(__c, __n); }
>
> std::size_t
> _M_bucket_index(const __node_type* __p, std::size_t __n) const
> noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>()))
> && noexcept(declval<const _H2&>()((__hash_code)0,
> (std::size_t)0)) )
> { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __n); }
>
> void
> _M_store_code(__node_type*, __hash_code) const
> { }
>
> void
> _M_copy_code(__node_type*, const __node_type*) const
> { }
>
> void
> _M_swap(_Hash_code_base& __x)
> {
> std::swap(_M_extract(), __x._M_extract());
> std::swap(_M_h1(), __x._M_h1());
> std::swap(_M_h2(), __x._M_h2());
> }
>
> const _ExtractKey&
> _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
>
> _ExtractKey&
> _M_extract() { return __ebo_extract_key::_S_get(*this); }
>
> const _H1&
> _M_h1() const { return __ebo_h1::_S_cget(*this); }
>
> _H1&
> _M_h1() { return __ebo_h1::_S_get(*this); }
>
> const _H2&
> _M_h2() const { return __ebo_h2::_S_cget(*this); }
>
> _H2&
> _M_h2() { return __ebo_h2::_S_get(*this); }
> };
>
>
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2>
> struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
> _Default_ranged_hash, true>
> : private _Hashtable_ebo_helper<0, _ExtractKey>,
> private _Hashtable_ebo_helper<1, _H1>,
> private _Hashtable_ebo_helper<2, _H2>
> {
> private:
>
> friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
> _Default_ranged_hash, true>;
>
> using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
> using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
> using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
>
> public:
> typedef _H1 hasher;
>
> hasher
> hash_function() const
> { return _M_h1(); }
>
> protected:
> typedef std::size_t __hash_code;
> typedef _Hash_node<_Value, true> __node_type;
>
>
> _Hash_code_base() = default;
> _Hash_code_base(const _ExtractKey& __ex,
> const _H1& __h1, const _H2& __h2,
> const _Default_ranged_hash&)
> : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
>
> __hash_code
> _M_hash_code(const _Key& __k) const
> { return _M_h1()(__k); }
>
> std::size_t
> _M_bucket_index(const _Key&, __hash_code __c,
> std::size_t __n) const
> { return _M_h2()(__c, __n); }
>
> std::size_t
> _M_bucket_index(const __node_type* __p, std::size_t __n) const
> noexcept( noexcept(declval<const _H2&>()((__hash_code)0,
> (std::size_t)0)) )
> { return _M_h2()(__p->_M_hash_code, __n); }
>
> void
> _M_store_code(__node_type* __n, __hash_code __c) const
> { __n->_M_hash_code = __c; }
>
> void
> _M_copy_code(__node_type* __to, const __node_type* __from) const
> { __to->_M_hash_code = __from->_M_hash_code; }
>
> void
> _M_swap(_Hash_code_base& __x)
> {
> std::swap(_M_extract(), __x._M_extract());
> std::swap(_M_h1(), __x._M_h1());
> std::swap(_M_h2(), __x._M_h2());
> }
>
> const _ExtractKey&
> _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
>
> _ExtractKey&
> _M_extract() { return __ebo_extract_key::_S_get(*this); }
>
> const _H1&
> _M_h1() const { return __ebo_h1::_S_cget(*this); }
>
> _H1&
> _M_h1() { return __ebo_h1::_S_get(*this); }
>
> const _H2&
> _M_h2() const { return __ebo_h2::_S_cget(*this); }
>
> _H2&
> _M_h2() { return __ebo_h2::_S_get(*this); }
> };
>
>
>
>
>
> template <typename _Key, typename _Value, typename _ExtractKey,
> typename _Equal, typename _HashCodeType,
> bool __cache_hash_code>
> struct _Equal_helper;
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _Equal, typename _HashCodeType>
> struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, true>
> {
> static bool
> _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
> const _Key& __k, _HashCodeType __c, _Hash_node<_Value, true>* __n)
> { return __c == __n->_M_hash_code && __eq(__k, __extract(__n->_M_v())); }
> };
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _Equal, typename _HashCodeType>
> struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, false>
> {
> static bool
> _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
> const _Key& __k, _HashCodeType, _Hash_node<_Value, false>* __n)
> { return __eq(__k, __extract(__n->_M_v())); }
> };
>
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash>
> struct _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, true>
> : private _Hashtable_ebo_helper<0, _H2>
> {
> protected:
> using __base_type = _Hashtable_ebo_helper<0, _H2>;
> using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, true>;
>
> _Local_iterator_base() = default;
> _Local_iterator_base(const __hash_code_base& __base,
> _Hash_node<_Value, true>* __p,
> std::size_t __bkt, std::size_t __bkt_count)
> : __base_type(__base._M_h2()),
> _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
>
> void
> _M_incr()
> {
> _M_cur = _M_cur->_M_next();
> if (_M_cur)
> {
> std::size_t __bkt
> = __base_type::_S_get(*this)(_M_cur->_M_hash_code,
> _M_bucket_count);
> if (__bkt != _M_bucket)
> _M_cur = nullptr;
> }
> }
>
> _Hash_node<_Value, true>* _M_cur;
> std::size_t _M_bucket;
> std::size_t _M_bucket_count;
>
> public:
> const void*
> _M_curr() const { return _M_cur; }
>
> std::size_t
> _M_get_bucket() const { return _M_bucket; }
> };
>
>
>
>
>
> template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
> struct _Hash_code_storage
> {
> __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
>
> _Tp*
> _M_h() { return _M_storage._M_ptr(); }
>
> const _Tp*
> _M_h() const { return _M_storage._M_ptr(); }
> };
>
>
> template<typename _Tp>
> struct _Hash_code_storage<_Tp, true>
> {
> static_assert( std::is_empty<_Tp>::value, "Type must be empty" );
>
>
>
> _Tp*
> _M_h() { return reinterpret_cast<_Tp*>(this); }
>
> const _Tp*
> _M_h() const { return reinterpret_cast<const _Tp*>(this); }
> };
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash>
> using __hash_code_for_local_iter
> = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, false>>;
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash>
> struct _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, false>
> : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash>
> {
> protected:
> using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, false>;
>
> _Local_iterator_base() : _M_bucket_count(-1) { }
>
> _Local_iterator_base(const __hash_code_base& __base,
> _Hash_node<_Value, false>* __p,
> std::size_t __bkt, std::size_t __bkt_count)
> : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
> { _M_init(__base); }
>
> ~_Local_iterator_base()
> {
> if (_M_bucket_count != -1)
> _M_destroy();
> }
>
> _Local_iterator_base(const _Local_iterator_base& __iter)
> : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket),
> _M_bucket_count(__iter._M_bucket_count)
> {
> if (_M_bucket_count != -1)
> _M_init(*__iter._M_h());
> }
>
> _Local_iterator_base&
> operator=(const _Local_iterator_base& __iter)
> {
> if (_M_bucket_count != -1)
> _M_destroy();
> _M_cur = __iter._M_cur;
> _M_bucket = __iter._M_bucket;
> _M_bucket_count = __iter._M_bucket_count;
> if (_M_bucket_count != -1)
> _M_init(*__iter._M_h());
> return *this;
> }
>
> void
> _M_incr()
> {
> _M_cur = _M_cur->_M_next();
> if (_M_cur)
> {
> std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur,
> _M_bucket_count);
> if (__bkt != _M_bucket)
> _M_cur = nullptr;
> }
> }
>
> _Hash_node<_Value, false>* _M_cur;
> std::size_t _M_bucket;
> std::size_t _M_bucket_count;
>
> void
> _M_init(const __hash_code_base& __base)
> { ::new(this->_M_h()) __hash_code_base(__base); }
>
> void
> _M_destroy() { this->_M_h()->~__hash_code_base(); }
>
> public:
> const void*
> _M_curr() const { return _M_cur; }
>
> std::size_t
> _M_get_bucket() const { return _M_bucket; }
> };
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash, bool __cache>
> inline bool
> operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>& __x,
> const _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>& __y)
> { return __x._M_curr() == __y._M_curr(); }
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash, bool __cache>
> inline bool
> operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>& __x,
> const _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>& __y)
> { return __x._M_curr() != __y._M_curr(); }
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash,
> bool __constant_iterators, bool __cache>
> struct _Local_iterator
> : public _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>
> {
> private:
> using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>;
> using __hash_code_base = typename __base_type::__hash_code_base;
> public:
> typedef _Value value_type;
> typedef typename std::conditional<__constant_iterators,
> const _Value*, _Value*>::type
> pointer;
> typedef typename std::conditional<__constant_iterators,
> const _Value&, _Value&>::type
> reference;
> typedef std::ptrdiff_t difference_type;
> typedef std::forward_iterator_tag iterator_category;
>
> _Local_iterator() = default;
>
> _Local_iterator(const __hash_code_base& __base,
> _Hash_node<_Value, __cache>* __p,
> std::size_t __bkt, std::size_t __bkt_count)
> : __base_type(__base, __p, __bkt, __bkt_count)
> { }
>
> reference
> operator*() const
> { return this->_M_cur->_M_v(); }
>
> pointer
> operator->() const
> { return this->_M_cur->_M_valptr(); }
>
> _Local_iterator&
> operator++()
> {
> this->_M_incr();
> return *this;
> }
>
> _Local_iterator
> operator++(int)
> {
> _Local_iterator __tmp(*this);
> this->_M_incr();
> return __tmp;
> }
> };
>
>
> template<typename _Key, typename _Value, typename _ExtractKey,
> typename _H1, typename _H2, typename _Hash,
> bool __constant_iterators, bool __cache>
> struct _Local_const_iterator
> : public _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>
> {
> private:
> using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash, __cache>;
> using __hash_code_base = typename __base_type::__hash_code_base;
>
> public:
> typedef _Value value_type;
> typedef const _Value* pointer;
> typedef const _Value& reference;
> typedef std::ptrdiff_t difference_type;
> typedef std::forward_iterator_tag iterator_category;
>
> _Local_const_iterator() = default;
>
> _Local_const_iterator(const __hash_code_base& __base,
> _Hash_node<_Value, __cache>* __p,
> std::size_t __bkt, std::size_t __bkt_count)
> : __base_type(__base, __p, __bkt, __bkt_count)
> { }
>
> _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash,
> __constant_iterators,
> __cache>& __x)
> : __base_type(__x)
> { }
>
> reference
> operator*() const
> { return this->_M_cur->_M_v(); }
>
> pointer
> operator->() const
> { return this->_M_cur->_M_valptr(); }
>
> _Local_const_iterator&
> operator++()
> {
> this->_M_incr();
> return *this;
> }
>
> _Local_const_iterator
> operator++(int)
> {
> _Local_const_iterator __tmp(*this);
> this->_M_incr();
> return __tmp;
> }
> };
># 1769 "/usr/include/c++/8/bits/hashtable_policy.h" 3
> template<typename _Key, typename _Value,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _Traits>
> struct _Hashtable_base
> : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
> _Traits::__hash_cached::value>,
> private _Hashtable_ebo_helper<0, _Equal>
> {
> public:
> typedef _Key key_type;
> typedef _Value value_type;
> typedef _Equal key_equal;
> typedef std::size_t size_type;
> typedef std::ptrdiff_t difference_type;
>
> using __traits_type = _Traits;
> using __hash_cached = typename __traits_type::__hash_cached;
> using __constant_iterators = typename __traits_type::__constant_iterators;
> using __unique_keys = typename __traits_type::__unique_keys;
>
> using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
> _H1, _H2, _Hash,
> __hash_cached::value>;
>
> using __hash_code = typename __hash_code_base::__hash_code;
> using __node_type = typename __hash_code_base::__node_type;
>
> using iterator = __detail::_Node_iterator<value_type,
> __constant_iterators::value,
> __hash_cached::value>;
>
> using const_iterator = __detail::_Node_const_iterator<value_type,
> __constant_iterators::value,
> __hash_cached::value>;
>
> using local_iterator = __detail::_Local_iterator<key_type, value_type,
> _ExtractKey, _H1, _H2, _Hash,
> __constant_iterators::value,
> __hash_cached::value>;
>
> using const_local_iterator = __detail::_Local_const_iterator<key_type,
> value_type,
> _ExtractKey, _H1, _H2, _Hash,
> __constant_iterators::value,
> __hash_cached::value>;
>
> using __ireturn_type = typename std::conditional<__unique_keys::value,
> std::pair<iterator, bool>,
> iterator>::type;
> private:
> using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;
> using _EqualHelper = _Equal_helper<_Key, _Value, _ExtractKey, _Equal,
> __hash_code, __hash_cached::value>;
>
> protected:
> _Hashtable_base() = default;
> _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2,
> const _Hash& __hash, const _Equal& __eq)
> : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq)
> { }
>
> bool
> _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const
> {
> return _EqualHelper::_S_equals(_M_eq(), this->_M_extract(),
> __k, __c, __n);
> }
>
> void
> _M_swap(_Hashtable_base& __x)
> {
> __hash_code_base::_M_swap(__x);
> std::swap(_M_eq(), __x._M_eq());
> }
>
> const _Equal&
> _M_eq() const { return _EqualEBO::_S_cget(*this); }
>
> _Equal&
> _M_eq() { return _EqualEBO::_S_get(*this); }
> };
>
>
>
>
>
>
> struct _Equality_base
> {
> protected:
> template<typename _Uiterator>
> static bool
> _S_is_permutation(_Uiterator, _Uiterator, _Uiterator);
> };
>
>
> template<typename _Uiterator>
> bool
> _Equality_base::
> _S_is_permutation(_Uiterator __first1, _Uiterator __last1,
> _Uiterator __first2)
> {
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> break;
>
> if (__first1 == __last1)
> return true;
>
> _Uiterator __last2 = __first2;
> std::advance(__last2, std::distance(__first1, __last1));
>
> for (_Uiterator __it1 = __first1; __it1 != __last1; ++__it1)
> {
> _Uiterator __tmp = __first1;
> while (__tmp != __it1 && !bool(*__tmp == *__it1))
> ++__tmp;
>
>
> if (__tmp != __it1)
> continue;
>
> std::ptrdiff_t __n2 = 0;
> for (__tmp = __first2; __tmp != __last2; ++__tmp)
> if (*__tmp == *__it1)
> ++__n2;
>
> if (!__n2)
> return false;
>
> std::ptrdiff_t __n1 = 0;
> for (__tmp = __it1; __tmp != __last1; ++__tmp)
> if (*__tmp == *__it1)
> ++__n1;
>
> if (__n1 != __n2)
> return false;
> }
> return true;
> }
># 1918 "/usr/include/c++/8/bits/hashtable_policy.h" 3
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits,
> bool _Unique_keys = _Traits::__unique_keys::value>
> struct _Equality;
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
> {
> using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>;
>
> bool
> _M_equal(const __hashtable&) const;
> };
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> bool
> _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
> _M_equal(const __hashtable& __other) const
> {
> const __hashtable* __this = static_cast<const __hashtable*>(this);
>
> if (__this->size() != __other.size())
> return false;
>
> for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
> {
> const auto __ity = __other.find(_ExtractKey()(*__itx));
> if (__ity == __other.end() || !bool(*__ity == *__itx))
> return false;
> }
> return true;
> }
>
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
> : public _Equality_base
> {
> using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>;
>
> bool
> _M_equal(const __hashtable&) const;
> };
>
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> bool
> _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits, false>::
> _M_equal(const __hashtable& __other) const
> {
> const __hashtable* __this = static_cast<const __hashtable*>(this);
>
> if (__this->size() != __other.size())
> return false;
>
> for (auto __itx = __this->begin(); __itx != __this->end();)
> {
> const auto __xrange = __this->equal_range(_ExtractKey()(*__itx));
> const auto __yrange = __other.equal_range(_ExtractKey()(*__itx));
>
> if (std::distance(__xrange.first, __xrange.second)
> != std::distance(__yrange.first, __yrange.second))
> return false;
>
> if (!_S_is_permutation(__xrange.first, __xrange.second,
> __yrange.first))
> return false;
>
> __itx = __xrange.second;
> }
> return true;
> }
>
>
>
>
>
> template<typename _NodeAlloc>
> struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
> {
> private:
> using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;
> public:
> using __node_type = typename _NodeAlloc::value_type;
> using __node_alloc_type = _NodeAlloc;
>
> using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;
>
> using __value_alloc_traits = typename __node_alloc_traits::template
> rebind_traits<typename __node_type::value_type>;
>
> using __node_base = __detail::_Hash_node_base;
> using __bucket_type = __node_base*;
> using __bucket_alloc_type =
> __alloc_rebind<__node_alloc_type, __bucket_type>;
> using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>;
>
> _Hashtable_alloc() = default;
> _Hashtable_alloc(const _Hashtable_alloc&) = default;
> _Hashtable_alloc(_Hashtable_alloc&&) = default;
>
> template<typename _Alloc>
> _Hashtable_alloc(_Alloc&& __a)
> : __ebo_node_alloc(std::forward<_Alloc>(__a))
> { }
>
> __node_alloc_type&
> _M_node_allocator()
> { return __ebo_node_alloc::_S_get(*this); }
>
> const __node_alloc_type&
> _M_node_allocator() const
> { return __ebo_node_alloc::_S_cget(*this); }
>
> template<typename... _Args>
> __node_type*
> _M_allocate_node(_Args&&... __args);
>
> void
> _M_deallocate_node(__node_type* __n);
>
>
> void
> _M_deallocate_nodes(__node_type* __n);
>
> __bucket_type*
> _M_allocate_buckets(std::size_t __n);
>
> void
> _M_deallocate_buckets(__bucket_type*, std::size_t __n);
> };
>
>
>
> template<typename _NodeAlloc>
> template<typename... _Args>
> typename _Hashtable_alloc<_NodeAlloc>::__node_type*
> _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
> {
> auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1);
> __node_type* __n = std::__to_address(__nptr);
> try
> {
> ::new ((void*)__n) __node_type;
> __node_alloc_traits::construct(_M_node_allocator(),
> __n->_M_valptr(),
> std::forward<_Args>(__args)...);
> return __n;
> }
> catch(...)
> {
> __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1);
> throw;
> }
> }
>
> template<typename _NodeAlloc>
> void
> _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n)
> {
> typedef typename __node_alloc_traits::pointer _Ptr;
> auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
> __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
> __n->~__node_type();
> __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
> }
>
> template<typename _NodeAlloc>
> void
> _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n)
> {
> while (__n)
> {
> __node_type* __tmp = __n;
> __n = __n->_M_next();
> _M_deallocate_node(__tmp);
> }
> }
>
> template<typename _NodeAlloc>
> typename _Hashtable_alloc<_NodeAlloc>::__bucket_type*
> _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __n)
> {
> __bucket_alloc_type __alloc(_M_node_allocator());
>
> auto __ptr = __bucket_alloc_traits::allocate(__alloc, __n);
> __bucket_type* __p = std::__to_address(__ptr);
> __builtin_memset(__p, 0, __n * sizeof(__bucket_type));
> return __p;
> }
>
> template<typename _NodeAlloc>
> void
> _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts,
> std::size_t __n)
> {
> typedef typename __bucket_alloc_traits::pointer _Ptr;
> auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
> __bucket_alloc_type __alloc(_M_node_allocator());
> __bucket_alloc_traits::deallocate(__alloc, __ptr, __n);
> }
>
>
>}
>
>}
># 36 "/usr/include/c++/8/bits/hashtable.h" 2 3
>
># 1 "/usr/include/c++/8/bits/node_handle.h" 1 3
># 34 "/usr/include/c++/8/bits/node_handle.h" 3
> 
># 35 "/usr/include/c++/8/bits/node_handle.h" 3
>
>
>
>
># 1 "/usr/include/c++/8/optional" 1 3
># 32 "/usr/include/c++/8/optional" 3
> 
># 33 "/usr/include/c++/8/optional" 3
># 43 "/usr/include/c++/8/optional" 3
># 1 "/usr/include/c++/8/bits/enable_special_members.h" 1 3
># 33 "/usr/include/c++/8/bits/enable_special_members.h" 3
> 
># 34 "/usr/include/c++/8/bits/enable_special_members.h" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> struct _Enable_default_constructor_tag
> {
> explicit constexpr _Enable_default_constructor_tag() = default;
> };
>
>
>
>
>
>
>template<bool _Switch, typename _Tag = void>
> struct _Enable_default_constructor
> {
> constexpr _Enable_default_constructor() noexcept = default;
> constexpr _Enable_default_constructor(_Enable_default_constructor const&)
> noexcept = default;
> constexpr _Enable_default_constructor(_Enable_default_constructor&&)
> noexcept = default;
> _Enable_default_constructor&
> operator=(_Enable_default_constructor const&) noexcept = default;
> _Enable_default_constructor&
> operator=(_Enable_default_constructor&&) noexcept = default;
>
>
> constexpr explicit
> _Enable_default_constructor(_Enable_default_constructor_tag) { }
> };
>
>
>
>
>
>
>
>template<bool _Switch, typename _Tag = void>
> struct _Enable_destructor { };
>
>
>
>
>
>
>template<bool _Copy, bool _CopyAssignment,
> bool _Move, bool _MoveAssignment,
> typename _Tag = void>
> struct _Enable_copy_move { };
># 93 "/usr/include/c++/8/bits/enable_special_members.h" 3
>template<bool _Default, bool _Destructor,
> bool _Copy, bool _CopyAssignment,
> bool _Move, bool _MoveAssignment,
> typename _Tag = void>
> struct _Enable_special_members
> : private _Enable_default_constructor<_Default, _Tag>,
> private _Enable_destructor<_Destructor, _Tag>,
> private _Enable_copy_move<_Copy, _CopyAssignment,
> _Move, _MoveAssignment,
> _Tag>
> { };
>
>
>
>template<typename _Tag>
> struct _Enable_default_constructor<false, _Tag>
> {
> constexpr _Enable_default_constructor() noexcept = delete;
> constexpr _Enable_default_constructor(_Enable_default_constructor const&)
> noexcept = default;
> constexpr _Enable_default_constructor(_Enable_default_constructor&&)
> noexcept = default;
> _Enable_default_constructor&
> operator=(_Enable_default_constructor const&) noexcept = default;
> _Enable_default_constructor&
> operator=(_Enable_default_constructor&&) noexcept = default;
>
>
> constexpr explicit
> _Enable_default_constructor(_Enable_default_constructor_tag) { }
> };
>
>template<typename _Tag>
> struct _Enable_destructor<false, _Tag>
> { ~_Enable_destructor() noexcept = delete; };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, true, true, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, false, true, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, false, true, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, true, false, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, true, false, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, false, false, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, false, false, true, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = default;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, true, true, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, true, true, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, false, true, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, false, true, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, true, false, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, true, false, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = default;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<true, false, false, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>template<typename _Tag>
> struct _Enable_copy_move<false, false, false, false, _Tag>
> {
> constexpr _Enable_copy_move() noexcept = default;
> constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
> constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move const&) noexcept = delete;
> _Enable_copy_move&
> operator=(_Enable_copy_move&&) noexcept = delete;
> };
>
>
>}
># 44 "/usr/include/c++/8/optional" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 56 "/usr/include/c++/8/optional" 3
> template<typename _Tp>
> class optional;
>
>
> struct nullopt_t
> {
>
>
>
>
>
> enum class _Construct { _Token };
>
>
> explicit constexpr nullopt_t(_Construct) { }
> };
>
>
> inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };
>
>
>
>
>
>
> class bad_optional_access : public exception
> {
> public:
> bad_optional_access() { }
> virtual const char* what() const noexcept override
> {return "bad optional access";}
>
> virtual ~bad_optional_access() noexcept = default;
> };
>
> void
> __throw_bad_optional_access()
> __attribute__((__noreturn__));
>
>
> inline void
> __throw_bad_optional_access()
> { (throw (bad_optional_access())); }
>
>
>
> template <typename _Tp,
> bool =
> is_trivially_destructible<_Tp>::value,
> bool =
> is_trivially_copy_assignable<_Tp>::value,
> bool =
> is_trivially_move_assignable<_Tp>::value>
> struct _Optional_payload
> {
> constexpr _Optional_payload()
> : _M_empty() {}
>
> template <typename... _Args>
> constexpr _Optional_payload(in_place_t, _Args&&... __args)
> : _M_payload(std::forward<_Args>(__args)...),
> _M_engaged(true) {}
>
> template<typename _Up, typename... _Args>
> constexpr _Optional_payload(std::initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(__il, std::forward<_Args>(__args)...),
> _M_engaged(true) {}
> constexpr
> _Optional_payload(bool __engaged, const _Optional_payload& __other)
> : _Optional_payload(__other)
> {}
>
> constexpr
> _Optional_payload(bool __engaged, _Optional_payload&& __other)
> : _Optional_payload(std::move(__other))
> {}
>
> constexpr _Optional_payload(const _Optional_payload& __other)
> {
> if (__other._M_engaged)
> this->_M_construct(__other._M_payload);
> }
>
> constexpr _Optional_payload(_Optional_payload&& __other)
> {
> if (__other._M_engaged)
> this->_M_construct(std::move(__other._M_payload));
> }
>
> _Optional_payload&
> operator=(const _Optional_payload& __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();
> }
> return *this;
> }
>
> _Optional_payload&
> operator=(_Optional_payload&& __other)
> noexcept(__and_<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();
> }
> return *this;
> }
>
> using _Stored_type = remove_const_t<_Tp>;
> struct _Empty_byte { };
> union {
> _Empty_byte _M_empty;
> _Stored_type _M_payload;
> };
> bool _M_engaged = false;
>
> ~_Optional_payload()
> {
> if (_M_engaged)
> _M_payload.~_Stored_type();
> }
>
> template<typename... _Args>
> void
> _M_construct(_Args&&... __args)
> noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
> {
> ::new ((void *) std::__addressof(this->_M_payload))
> _Stored_type(std::forward<_Args>(__args)...);
> this->_M_engaged = true;
> }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> return this->_M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> return this->_M_payload;
> }
>
>
> void
> _M_reset() noexcept
> {
> if (this->_M_engaged)
> {
> this->_M_engaged = false;
> this->_M_payload.~_Stored_type();
> }
> }
> };
>
>
> template <typename _Tp>
> struct _Optional_payload<_Tp, true, true, true>
> {
> constexpr _Optional_payload()
> : _M_empty(), _M_engaged(false) {}
>
> template<typename... _Args>
> constexpr _Optional_payload(in_place_t, _Args&&... __args)
> : _M_payload(std::forward<_Args>(__args)...),
> _M_engaged(true)
> {}
>
> template<typename _Up, typename... _Args>
> constexpr _Optional_payload(std::initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(__il, std::forward<_Args>(__args)...),
> _M_engaged(true) {}
>
> template <class _Up> struct __ctor_tag {};
>
> constexpr _Optional_payload(__ctor_tag<bool>,
> const _Tp& __other)
> : _M_payload(__other),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(__ctor_tag<void>)
> : _M_empty(), _M_engaged(false)
> {}
>
> constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
> : _M_payload(std::move(__other)),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(bool __engaged,
> const _Optional_payload& __other)
> : _Optional_payload(__engaged ?
> _Optional_payload(__ctor_tag<bool>{},
> __other._M_payload) :
> _Optional_payload(__ctor_tag<void>{}))
> {}
>
> constexpr _Optional_payload(bool __engaged,
> _Optional_payload&& __other)
> : _Optional_payload(__engaged
> ? _Optional_payload(__ctor_tag<bool>{},
> std::move(__other._M_payload))
> : _Optional_payload(__ctor_tag<void>{}))
> {}
>
> using _Stored_type = remove_const_t<_Tp>;
> struct _Empty_byte { };
> union {
> _Empty_byte _M_empty;
> _Stored_type _M_payload;
> };
> bool _M_engaged;
> };
>
>
> template <typename _Tp>
> struct _Optional_payload<_Tp, true, false, true>
> {
> constexpr _Optional_payload()
> : _M_empty(), _M_engaged(false) {}
>
> template<typename... _Args>
> constexpr _Optional_payload(in_place_t, _Args&&... __args)
> : _M_payload(std::forward<_Args>(__args)...),
> _M_engaged(true)
> {}
>
> template<typename _Up, typename... _Args>
> constexpr _Optional_payload(std::initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(__il, std::forward<_Args>(__args)...),
> _M_engaged(true) {}
>
> template <class _Up> struct __ctor_tag {};
>
> constexpr _Optional_payload(__ctor_tag<bool>,
> const _Tp& __other)
> : _M_payload(__other),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(__ctor_tag<void>)
> : _M_empty(), _M_engaged(false)
> {}
>
> constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
> : _M_payload(std::move(__other)),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(bool __engaged,
> const _Optional_payload& __other)
> : _Optional_payload(__engaged ?
> _Optional_payload(__ctor_tag<bool>{},
> __other._M_payload) :
> _Optional_payload(__ctor_tag<void>{}))
> {}
>
> constexpr _Optional_payload(bool __engaged,
> _Optional_payload&& __other)
> : _Optional_payload(__engaged
> ? _Optional_payload(__ctor_tag<bool>{},
> std::move(__other._M_payload))
> : _Optional_payload(__ctor_tag<void>{}))
> {}
>
> _Optional_payload(const _Optional_payload&) = default;
> _Optional_payload(_Optional_payload&&) = default;
>
> _Optional_payload&
> operator=(const _Optional_payload& __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();
> }
> return *this;
> }
>
> _Optional_payload&
> operator=(_Optional_payload&& __other) = default;
>
> using _Stored_type = remove_const_t<_Tp>;
> struct _Empty_byte { };
> union {
> _Empty_byte _M_empty;
> _Stored_type _M_payload;
> };
> bool _M_engaged;
>
> template<typename... _Args>
> void
> _M_construct(_Args&&... __args)
> noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
> {
> ::new ((void *) std::__addressof(this->_M_payload))
> _Stored_type(std::forward<_Args>(__args)...);
> this->_M_engaged = true;
> }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> return this->_M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> return this->_M_payload;
> }
>
>
> void
> _M_reset() noexcept
> {
> if (this->_M_engaged)
> {
> this->_M_engaged = false;
> this->_M_payload.~_Stored_type();
> }
> }
> };
>
>
> template <typename _Tp>
> struct _Optional_payload<_Tp, true, true, false>
> {
> constexpr _Optional_payload()
> : _M_empty(), _M_engaged(false) {}
>
> template<typename... _Args>
> constexpr _Optional_payload(in_place_t, _Args&&... __args)
> : _M_payload(std::forward<_Args>(__args)...),
> _M_engaged(true)
> {}
>
> template<typename _Up, typename... _Args>
> constexpr _Optional_payload(std::initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(__il, std::forward<_Args>(__args)...),
> _M_engaged(true) {}
>
> template <class _Up> struct __ctor_tag {};
>
> constexpr _Optional_payload(__ctor_tag<bool>,
> const _Tp& __other)
> : _M_payload(__other),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(__ctor_tag<void>)
> : _M_empty(), _M_engaged(false)
> {}
>
> constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
> : _M_payload(std::move(__other)),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(bool __engaged,
> const _Optional_payload& __other)
> : _Optional_payload(__engaged ?
> _Optional_payload(__ctor_tag<bool>{},
> __other._M_payload) :
> _Optional_payload(__ctor_tag<void>{}))
> {}
>
> constexpr _Optional_payload(bool __engaged,
> _Optional_payload&& __other)
> : _Optional_payload(__engaged
> ? _Optional_payload(__ctor_tag<bool>{},
> std::move(__other._M_payload))
> : _Optional_payload(__ctor_tag<void>{}))
> {}
>
> _Optional_payload(const _Optional_payload&) = default;
> _Optional_payload(_Optional_payload&&) = default;
>
> _Optional_payload&
> operator=(const _Optional_payload& __other) = default;
>
> _Optional_payload&
> operator=(_Optional_payload&& __other)
> noexcept(__and_<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();
> }
> return *this;
> }
>
> using _Stored_type = remove_const_t<_Tp>;
> struct _Empty_byte { };
> union {
> _Empty_byte _M_empty;
> _Stored_type _M_payload;
> };
> bool _M_engaged;
>
> template<typename... _Args>
> void
> _M_construct(_Args&&... __args)
> noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
> {
> ::new ((void *) std::__addressof(this->_M_payload))
> _Stored_type(std::forward<_Args>(__args)...);
> this->_M_engaged = true;
> }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> return this->_M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> return this->_M_payload;
> }
>
>
> void
> _M_reset() noexcept
> {
> if (this->_M_engaged)
> {
> this->_M_engaged = false;
> this->_M_payload.~_Stored_type();
> }
> }
> };
>
>
> template <typename _Tp>
> struct _Optional_payload<_Tp, true, false, false>
> {
> constexpr _Optional_payload()
> : _M_empty(), _M_engaged(false) {}
>
> template<typename... _Args>
> constexpr _Optional_payload(in_place_t, _Args&&... __args)
> : _M_payload(std::forward<_Args>(__args)...),
> _M_engaged(true)
> {}
>
> template<typename _Up, typename... _Args>
> constexpr _Optional_payload(std::initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(__il, std::forward<_Args>(__args)...),
> _M_engaged(true) {}
>
> template <class _Up> struct __ctor_tag {};
>
> constexpr _Optional_payload(__ctor_tag<bool>,
> const _Tp& __other)
> : _M_payload(__other),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(__ctor_tag<void>)
> : _M_empty(), _M_engaged(false)
> {}
>
> constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
> : _M_payload(std::move(__other)),
> _M_engaged(true)
> {}
>
> constexpr _Optional_payload(bool __engaged,
> const _Optional_payload& __other)
> : _Optional_payload(__engaged ?
> _Optional_payload(__ctor_tag<bool>{},
> __other._M_payload) :
> _Optional_payload(__ctor_tag<void>{}))
> {}
>
> constexpr _Optional_payload(bool __engaged,
> _Optional_payload&& __other)
> : _Optional_payload(__engaged
> ? _Optional_payload(__ctor_tag<bool>{},
> std::move(__other._M_payload))
> : _Optional_payload(__ctor_tag<void>{}))
> {}
>
> _Optional_payload(const _Optional_payload&) = default;
> _Optional_payload(_Optional_payload&&) = default;
>
> _Optional_payload&
> operator=(const _Optional_payload& __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();
> }
> return *this;
> }
>
> _Optional_payload&
> operator=(_Optional_payload&& __other)
> noexcept(__and_<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();
> }
> return *this;
> }
>
> using _Stored_type = remove_const_t<_Tp>;
> struct _Empty_byte { };
> union {
> _Empty_byte _M_empty;
> _Stored_type _M_payload;
> };
> bool _M_engaged;
>
> template<typename... _Args>
> void
> _M_construct(_Args&&... __args)
> noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
> {
> ::new ((void *) std::__addressof(this->_M_payload))
> _Stored_type(std::forward<_Args>(__args)...);
> this->_M_engaged = true;
> }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> return this->_M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> return this->_M_payload;
> }
>
>
> void
> _M_reset() noexcept
> {
> if (this->_M_engaged)
> {
> this->_M_engaged = false;
> this->_M_payload.~_Stored_type();
> }
> }
> };
>
> template<typename _Tp, typename _Dp>
> class _Optional_base_impl
> {
> protected:
> using _Stored_type = remove_const_t<_Tp>;
>
>
>
> template<typename... _Args>
> void
> _M_construct(_Args&&... __args)
> noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
> {
> ::new
> (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
> _Stored_type(std::forward<_Args>(__args)...);
> static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
> }
>
> void
> _M_destruct() noexcept
> {
> static_cast<_Dp*>(this)->_M_payload._M_engaged = false;
> static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type();
> }
>
>
> void
> _M_reset() noexcept
> {
> if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
> static_cast<_Dp*>(this)->_M_destruct();
> }
> };
># 695 "/usr/include/c++/8/optional" 3
> template<typename _Tp,
> bool = is_trivially_copy_constructible_v<_Tp>,
> bool = is_trivially_move_constructible_v<_Tp>>
> class _Optional_base
>
> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
> {
> friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
> public:
>
>
> constexpr _Optional_base() = default;
>
>
> template<typename... _Args,
> enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
> : _M_payload(in_place,
> std::forward<_Args>(__args)...) { }
>
> template<typename _Up, typename... _Args,
> enable_if_t<is_constructible_v<_Tp,
> initializer_list<_Up>&,
> _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t,
> initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(in_place,
> __il, std::forward<_Args>(__args)...)
> { }
>
>
> constexpr _Optional_base(const _Optional_base& __other)
> : _M_payload(__other._M_payload._M_engaged,
> __other._M_payload)
> { }
>
> constexpr _Optional_base(_Optional_base&& __other)
> noexcept(is_nothrow_move_constructible<_Tp>())
> : _M_payload(__other._M_payload._M_engaged,
> std::move(__other._M_payload))
> { }
>
>
> _Optional_base& operator=(const _Optional_base&) = default;
> _Optional_base& operator=(_Optional_base&&) = default;
>
> protected:
>
> constexpr bool _M_is_engaged() const noexcept
> { return this->_M_payload._M_engaged; }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> private:
> _Optional_payload<_Tp> _M_payload;
> };
>
> template<typename _Tp>
> class _Optional_base<_Tp, false, true>
> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
> {
> friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
> public:
>
>
> constexpr _Optional_base() = default;
>
>
> template<typename... _Args,
> enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
> : _M_payload(in_place,
> std::forward<_Args>(__args)...) { }
>
> template<typename _Up, typename... _Args,
> enable_if_t<is_constructible_v<_Tp,
> initializer_list<_Up>&,
> _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t,
> initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(in_place,
> __il, std::forward<_Args>(__args)...)
> { }
>
>
> constexpr _Optional_base(const _Optional_base& __other)
> : _M_payload(__other._M_payload._M_engaged,
> __other._M_payload)
> { }
>
> constexpr _Optional_base(_Optional_base&& __other) = default;
>
>
> _Optional_base& operator=(const _Optional_base&) = default;
> _Optional_base& operator=(_Optional_base&&) = default;
>
> protected:
>
> constexpr bool _M_is_engaged() const noexcept
> { return this->_M_payload._M_engaged; }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> private:
> _Optional_payload<_Tp> _M_payload;
> };
>
> template<typename _Tp>
> class _Optional_base<_Tp, true, false>
> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
> {
> friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
> public:
>
>
> constexpr _Optional_base() = default;
>
>
> template<typename... _Args,
> enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
> : _M_payload(in_place,
> std::forward<_Args>(__args)...) { }
>
> template<typename _Up, typename... _Args,
> enable_if_t<is_constructible_v<_Tp,
> initializer_list<_Up>&,
> _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t,
> initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(in_place,
> __il, std::forward<_Args>(__args)...)
> { }
>
>
> constexpr _Optional_base(const _Optional_base& __other) = default;
>
> constexpr _Optional_base(_Optional_base&& __other)
> noexcept(is_nothrow_move_constructible<_Tp>())
> : _M_payload(__other._M_payload._M_engaged,
> std::move(__other._M_payload))
> { }
>
>
> _Optional_base& operator=(const _Optional_base&) = default;
> _Optional_base& operator=(_Optional_base&&) = default;
>
> protected:
>
> constexpr bool _M_is_engaged() const noexcept
> { return this->_M_payload._M_engaged; }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> private:
> _Optional_payload<_Tp> _M_payload;
> };
>
> template<typename _Tp>
> class _Optional_base<_Tp, true, true>
> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
> {
> friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
> public:
>
>
> constexpr _Optional_base() = default;
>
>
> template<typename... _Args,
> enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
> : _M_payload(in_place,
> std::forward<_Args>(__args)...) { }
>
> template<typename _Up, typename... _Args,
> enable_if_t<is_constructible_v<_Tp,
> initializer_list<_Up>&,
> _Args&&...>, bool> = false>
> constexpr explicit _Optional_base(in_place_t,
> initializer_list<_Up> __il,
> _Args&&... __args)
> : _M_payload(in_place,
> __il, std::forward<_Args>(__args)...)
> { }
>
>
> constexpr _Optional_base(const _Optional_base& __other) = default;
> constexpr _Optional_base(_Optional_base&& __other) = default;
>
>
> _Optional_base& operator=(const _Optional_base&) = default;
> _Optional_base& operator=(_Optional_base&&) = default;
>
> protected:
>
> constexpr bool _M_is_engaged() const noexcept
> { return this->_M_payload._M_engaged; }
>
>
> constexpr _Tp&
> _M_get() noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> constexpr const _Tp&
> _M_get() const noexcept
> {
> ;
> return this->_M_payload._M_payload;
> }
>
> private:
> _Optional_payload<_Tp> _M_payload;
> };
>
> template<typename _Tp>
> class optional;
>
> template<typename _Tp, typename _Up>
> using __converts_from_optional =
> __or_<is_constructible<_Tp, const optional<_Up>&>,
> is_constructible<_Tp, optional<_Up>&>,
> is_constructible<_Tp, const optional<_Up>&&>,
> is_constructible<_Tp, optional<_Up>&&>,
> is_convertible<const optional<_Up>&, _Tp>,
> is_convertible<optional<_Up>&, _Tp>,
> is_convertible<const optional<_Up>&&, _Tp>,
> is_convertible<optional<_Up>&&, _Tp>>;
>
> template<typename _Tp, typename _Up>
> using __assigns_from_optional =
> __or_<is_assignable<_Tp&, const optional<_Up>&>,
> is_assignable<_Tp&, optional<_Up>&>,
> is_assignable<_Tp&, const optional<_Up>&&>,
> is_assignable<_Tp&, optional<_Up>&&>>;
>
>
>
>
> template<typename _Tp>
> class optional
> : private _Optional_base<_Tp>,
> private _Enable_copy_move<
>
> is_copy_constructible<_Tp>::value,
>
> __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value,
>
> is_move_constructible<_Tp>::value,
>
> __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value,
>
> optional<_Tp>>
> {
> static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
> static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
> static_assert(!is_reference_v<_Tp>);
>
> private:
> using _Base = _Optional_base<_Tp>;
>
> public:
> using value_type = _Tp;
>
> constexpr optional() = default;
>
> constexpr optional(nullopt_t) noexcept { }
>
>
> template <typename _Up = _Tp,
> enable_if_t<__and_<
> __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
> __not_<is_same<in_place_t, decay_t<_Up>>>,
> is_constructible<_Tp, _Up&&>,
> is_convertible<_Up&&, _Tp>
> >::value, bool> = true>
> constexpr optional(_Up&& __t)
> : _Base(std::in_place, std::forward<_Up>(__t)) { }
>
> template <typename _Up = _Tp,
> enable_if_t<__and_<
> __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
> __not_<is_same<in_place_t, decay_t<_Up>>>,
> is_constructible<_Tp, _Up&&>,
> __not_<is_convertible<_Up&&, _Tp>>
> >::value, bool> = false>
> explicit constexpr optional(_Up&& __t)
> : _Base(std::in_place, std::forward<_Up>(__t)) { }
>
> template <typename _Up,
> enable_if_t<__and_<
> __not_<is_same<_Tp, _Up>>,
> is_constructible<_Tp, const _Up&>,
> is_convertible<const _Up&, _Tp>,
> __not_<__converts_from_optional<_Tp, _Up>>
> >::value, bool> = true>
> constexpr optional(const optional<_Up>& __t)
> {
> if (__t)
> emplace(*__t);
> }
>
> template <typename _Up,
> enable_if_t<__and_<
> __not_<is_same<_Tp, _Up>>,
> is_constructible<_Tp, const _Up&>,
> __not_<is_convertible<const _Up&, _Tp>>,
> __not_<__converts_from_optional<_Tp, _Up>>
> >::value, bool> = false>
> explicit constexpr optional(const optional<_Up>& __t)
> {
> if (__t)
> emplace(*__t);
> }
>
> template <typename _Up,
> enable_if_t<__and_<
> __not_<is_same<_Tp, _Up>>,
> is_constructible<_Tp, _Up&&>,
> is_convertible<_Up&&, _Tp>,
> __not_<__converts_from_optional<_Tp, _Up>>
> >::value, bool> = true>
> constexpr optional(optional<_Up>&& __t)
> {
> if (__t)
> emplace(std::move(*__t));
> }
>
> template <typename _Up,
> enable_if_t<__and_<
> __not_<is_same<_Tp, _Up>>,
> is_constructible<_Tp, _Up&&>,
> __not_<is_convertible<_Up&&, _Tp>>,
> __not_<__converts_from_optional<_Tp, _Up>>
> >::value, bool> = false>
> explicit constexpr optional(optional<_Up>&& __t)
> {
> if (__t)
> emplace(std::move(*__t));
> }
>
> template<typename... _Args,
> enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
> explicit constexpr optional(in_place_t, _Args&&... __args)
> : _Base(std::in_place, std::forward<_Args>(__args)...) { }
>
> template<typename _Up, typename... _Args,
> enable_if_t<is_constructible_v<_Tp,
> initializer_list<_Up>&,
> _Args&&...>, bool> = false>
> explicit constexpr optional(in_place_t,
> initializer_list<_Up> __il,
> _Args&&... __args)
> : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
>
>
> optional&
> operator=(nullopt_t) noexcept
> {
> this->_M_reset();
> return *this;
> }
>
> template<typename _Up = _Tp>
> enable_if_t<__and_<
> __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
> is_constructible<_Tp, _Up>,
> __not_<__and_<is_scalar<_Tp>,
> is_same<_Tp, decay_t<_Up>>>>,
> is_assignable<_Tp&, _Up>>::value,
> optional&>
> operator=(_Up&& __u)
> {
> if (this->_M_is_engaged())
> this->_M_get() = std::forward<_Up>(__u);
> else
> this->_M_construct(std::forward<_Up>(__u));
>
> return *this;
> }
>
> template<typename _Up>
> enable_if_t<__and_<
> __not_<is_same<_Tp, _Up>>,
> is_constructible<_Tp, const _Up&>,
> is_assignable<_Tp&, _Up>,
> __not_<__converts_from_optional<_Tp, _Up>>,
> __not_<__assigns_from_optional<_Tp, _Up>>
> >::value,
> optional&>
> operator=(const optional<_Up>& __u)
> {
> if (__u)
> {
> if (this->_M_is_engaged())
> this->_M_get() = *__u;
> else
> this->_M_construct(*__u);
> }
> else
> {
> this->_M_reset();
> }
> return *this;
> }
>
> template<typename _Up>
> enable_if_t<__and_<
> __not_<is_same<_Tp, _Up>>,
> is_constructible<_Tp, _Up>,
> is_assignable<_Tp&, _Up>,
> __not_<__converts_from_optional<_Tp, _Up>>,
> __not_<__assigns_from_optional<_Tp, _Up>>
> >::value,
> optional&>
> operator=(optional<_Up>&& __u)
> {
> if (__u)
> {
> if (this->_M_is_engaged())
> this->_M_get() = std::move(*__u);
> else
> this->_M_construct(std::move(*__u));
> }
> else
> {
> this->_M_reset();
> }
>
> return *this;
> }
>
> template<typename... _Args>
> enable_if_t<is_constructible<_Tp, _Args&&...>::value, _Tp&>
> emplace(_Args&&... __args)
> {
> this->_M_reset();
> this->_M_construct(std::forward<_Args>(__args)...);
> return this->_M_get();
> }
>
> template<typename _Up, typename... _Args>
> enable_if_t<is_constructible<_Tp, initializer_list<_Up>&,
> _Args&&...>::value, _Tp&>
> emplace(initializer_list<_Up> __il, _Args&&... __args)
> {
> this->_M_reset();
> this->_M_construct(__il, std::forward<_Args>(__args)...);
> return this->_M_get();
> }
>
>
>
>
> void
> swap(optional& __other)
> noexcept(is_nothrow_move_constructible<_Tp>()
> && is_nothrow_swappable_v<_Tp>)
> {
> using std::swap;
>
> if (this->_M_is_engaged() && __other._M_is_engaged())
> swap(this->_M_get(), __other._M_get());
> else if (this->_M_is_engaged())
> {
> __other._M_construct(std::move(this->_M_get()));
> this->_M_destruct();
> }
> else if (__other._M_is_engaged())
> {
> this->_M_construct(std::move(__other._M_get()));
> __other._M_destruct();
> }
> }
>
>
> constexpr const _Tp*
> operator->() const
> { return std::__addressof(this->_M_get()); }
>
> _Tp*
> operator->()
> { return std::__addressof(this->_M_get()); }
>
> constexpr const _Tp&
> operator*() const&
> { return this->_M_get(); }
>
> constexpr _Tp&
> operator*()&
> { return this->_M_get(); }
>
> constexpr _Tp&&
> operator*()&&
> { return std::move(this->_M_get()); }
>
> constexpr const _Tp&&
> operator*() const&&
> { return std::move(this->_M_get()); }
>
> constexpr explicit operator bool() const noexcept
> { return this->_M_is_engaged(); }
>
> constexpr bool has_value() const noexcept
> { return this->_M_is_engaged(); }
>
> constexpr const _Tp&
> value() const&
> {
> return this->_M_is_engaged()
> ? this->_M_get()
> : (__throw_bad_optional_access(),
> this->_M_get());
> }
>
> constexpr _Tp&
> value()&
> {
> return this->_M_is_engaged()
> ? this->_M_get()
> : (__throw_bad_optional_access(),
> this->_M_get());
> }
>
> constexpr _Tp&&
> value()&&
> {
> return this->_M_is_engaged()
> ? std::move(this->_M_get())
> : (__throw_bad_optional_access(),
> std::move(this->_M_get()));
> }
>
> constexpr const _Tp&&
> value() const&&
> {
> return this->_M_is_engaged()
> ? std::move(this->_M_get())
> : (__throw_bad_optional_access(),
> std::move(this->_M_get()));
> }
>
> template<typename _Up>
> constexpr _Tp
> value_or(_Up&& __u) const&
> {
> static_assert(is_copy_constructible_v<_Tp>);
> static_assert(is_convertible_v<_Up&&, _Tp>);
>
> return this->_M_is_engaged()
> ? this->_M_get()
> : static_cast<_Tp>(std::forward<_Up>(__u));
> }
>
> template<typename _Up>
> _Tp
> value_or(_Up&& __u) &&
> {
> static_assert(is_move_constructible_v<_Tp>);
> static_assert(is_convertible_v<_Up&&, _Tp>);
>
> return this->_M_is_engaged()
> ? std::move(this->_M_get())
> : static_cast<_Tp>(std::forward<_Up>(__u));
> }
> void reset() noexcept { this->_M_reset(); }
> };
>
> template<typename _Tp>
> using __optional_relop_t =
> enable_if_t<is_convertible<_Tp, bool>::value, bool>;
>
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
> {
> return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
> && (!__lhs || *__lhs == *__rhs);
> }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
> {
> return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
> || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
> }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
> {
> return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
> }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
> {
> return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
> }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
> {
> return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
> }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
> {
> return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
> }
>
>
> template<typename _Tp>
> constexpr bool
> operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
> { return !__lhs; }
>
> template<typename _Tp>
> constexpr bool
> operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
> { return !__rhs; }
>
> template<typename _Tp>
> constexpr bool
> operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
> { return static_cast<bool>(__lhs); }
>
> template<typename _Tp>
> constexpr bool
> operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
> { return static_cast<bool>(__rhs); }
>
> template<typename _Tp>
> constexpr bool
> operator<(const optional<_Tp>& , nullopt_t) noexcept
> { return false; }
>
> template<typename _Tp>
> constexpr bool
> operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
> { return static_cast<bool>(__rhs); }
>
> template<typename _Tp>
> constexpr bool
> operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
> { return static_cast<bool>(__lhs); }
>
> template<typename _Tp>
> constexpr bool
> operator>(nullopt_t, const optional<_Tp>& ) noexcept
> { return false; }
>
> template<typename _Tp>
> constexpr bool
> operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
> { return !__lhs; }
>
> template<typename _Tp>
> constexpr bool
> operator<=(nullopt_t, const optional<_Tp>& ) noexcept
> { return true; }
>
> template<typename _Tp>
> constexpr bool
> operator>=(const optional<_Tp>& , nullopt_t) noexcept
> { return true; }
>
> template<typename _Tp>
> constexpr bool
> operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
> { return !__rhs; }
>
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
> { return __lhs && *__lhs == __rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
> -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
> { return __rhs && __lhs == *__rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
> { return !__lhs || *__lhs != __rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
> -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
> { return !__rhs || __lhs != *__rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
> { return !__lhs || *__lhs < __rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
> -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
> { return __rhs && __lhs < *__rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
> { return __lhs && *__lhs > __rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
> -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
> { return !__rhs || __lhs > *__rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
> { return !__lhs || *__lhs <= __rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
> -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
> { return __rhs && __lhs <= *__rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
> -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
> { return __lhs && *__lhs >= __rhs; }
>
> template<typename _Tp, typename _Up>
> constexpr auto
> operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
> -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
> { return !__rhs || __lhs >= *__rhs; }
>
>
>
>
>
> template<typename _Tp>
> inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
> swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
> noexcept(noexcept(__lhs.swap(__rhs)))
> { __lhs.swap(__rhs); }
>
> template<typename _Tp>
> enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
> swap(optional<_Tp>&, optional<_Tp>&) = delete;
>
> template<typename _Tp>
> constexpr optional<decay_t<_Tp>>
> make_optional(_Tp&& __t)
> { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
>
> template<typename _Tp, typename ..._Args>
> constexpr optional<_Tp>
> make_optional(_Args&&... __args)
> { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }
>
> template<typename _Tp, typename _Up, typename ..._Args>
> constexpr optional<_Tp>
> make_optional(initializer_list<_Up> __il, _Args&&... __args)
> { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }
>
>
>
> template<typename _Tp, typename _Up = remove_const_t<_Tp>,
> bool = __poison_hash<_Up>::__enable_hash_call>
> struct __optional_hash_call_base
> {
> size_t
> operator()(const optional<_Tp>& __t) const
> noexcept(noexcept(hash<_Up>{}(*__t)))
> {
>
>
> constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
> return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
> }
> };
>
> template<typename _Tp, typename _Up>
> struct __optional_hash_call_base<_Tp, _Up, false> {};
>
> template<typename _Tp>
> struct hash<optional<_Tp>>
> : private __poison_hash<remove_const_t<_Tp>>,
> public __optional_hash_call_base<_Tp>
> {
> using result_type [[__deprecated__]] = size_t;
> using argument_type [[__deprecated__]] = optional<_Tp>;
> };
>
> template<typename _Tp>
> struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
> { };
>
>
>
>
> template <typename _Tp> optional(_Tp) -> optional<_Tp>;
>
>
>
>}
># 40 "/usr/include/c++/8/bits/node_handle.h" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Val, typename _NodeAlloc>
> class _Node_handle_common
> {
> using _AllocTraits = allocator_traits<_NodeAlloc>;
>
> public:
> using allocator_type = __alloc_rebind<_NodeAlloc, _Val>;
>
> allocator_type
> get_allocator() const noexcept
> {
> ;
> return allocator_type(*_M_alloc);
> }
>
> explicit operator bool() const noexcept { return _M_ptr != nullptr; }
>
> [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; }
>
> protected:
> constexpr _Node_handle_common() noexcept : _M_ptr(), _M_alloc() {}
>
> ~_Node_handle_common() { _M_destroy(); }
>
> _Node_handle_common(_Node_handle_common&& __nh) noexcept
> : _M_ptr(__nh._M_ptr), _M_alloc(std::move(__nh._M_alloc))
> {
> __nh._M_ptr = nullptr;
> __nh._M_alloc = nullopt;
> }
>
> _Node_handle_common&
> operator=(_Node_handle_common&& __nh) noexcept
> {
> _M_destroy();
> _M_ptr = __nh._M_ptr;
> if constexpr (is_move_assignable_v<_NodeAlloc>)
> {
> if (_AllocTraits::propagate_on_container_move_assignment::value
> || !this->_M_alloc)
> this->_M_alloc = std::move(__nh._M_alloc);
> else
> {
> ;
> }
> }
> else
> {
> ;
> }
> __nh._M_ptr = nullptr;
> __nh._M_alloc = nullopt;
> return *this;
> }
>
> _Node_handle_common(typename _AllocTraits::pointer __ptr,
> const _NodeAlloc& __alloc)
> : _M_ptr(__ptr), _M_alloc(__alloc) { }
>
> void
> _M_swap(_Node_handle_common& __nh) noexcept
> {
> using std::swap;
> swap(_M_ptr, __nh._M_ptr);
> if (_AllocTraits::propagate_on_container_swap
> || !_M_alloc || !__nh._M_alloc)
> _M_alloc.swap(__nh._M_alloc);
> else
> {
> ;
> }
> }
>
> private:
> void
> _M_destroy() noexcept
> {
> if (_M_ptr != nullptr)
> {
> allocator_type __alloc(*_M_alloc);
> allocator_traits<allocator_type>::destroy(__alloc,
> _M_ptr->_M_valptr());
> _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1);
> }
> }
>
> protected:
> typename _AllocTraits::pointer _M_ptr;
> private:
> optional<_NodeAlloc> _M_alloc;
>
> template<typename _Key2, typename _Value2, typename _KeyOfValue,
> typename _Compare, typename _ValueAlloc>
> friend class _Rb_tree;
> };
>
>
> template<typename _Key, typename _Value, typename _NodeAlloc>
> class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc>
> {
> public:
> constexpr _Node_handle() noexcept = default;
> ~_Node_handle() = default;
> _Node_handle(_Node_handle&&) noexcept = default;
>
> _Node_handle&
> operator=(_Node_handle&&) noexcept = default;
>
> using key_type = _Key;
> using mapped_type = typename _Value::second_type;
>
> key_type&
> key() const noexcept
> {
> ;
> return *_M_pkey;
> }
>
> mapped_type&
> mapped() const noexcept
> {
> ;
> return *_M_pmapped;
> }
>
> void
> swap(_Node_handle& __nh) noexcept
> {
> this->_M_swap(__nh);
> using std::swap;
> swap(_M_pkey, __nh._M_pkey);
> swap(_M_pmapped, __nh._M_pmapped);
> }
>
> friend void
> swap(_Node_handle& __x, _Node_handle& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> private:
> using _AllocTraits = allocator_traits<_NodeAlloc>;
>
> _Node_handle(typename _AllocTraits::pointer __ptr,
> const _NodeAlloc& __alloc)
> : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc)
> {
> if (__ptr)
> {
> auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first);
> _M_pkey = _S_pointer_to(__key);
> _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second);
> }
> else
> {
> _M_pkey = nullptr;
> _M_pmapped = nullptr;
> }
> }
>
> template<typename _Tp>
> using __pointer
> = __ptr_rebind<typename _AllocTraits::pointer,
> remove_reference_t<_Tp>>;
>
> __pointer<_Key> _M_pkey = nullptr;
> __pointer<typename _Value::second_type> _M_pmapped = nullptr;
>
> template<typename _Tp>
> __pointer<_Tp>
> _S_pointer_to(_Tp& __obj)
> { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); }
>
> const key_type&
> _M_key() const noexcept { return key(); }
>
> template<typename _Key2, typename _Value2, typename _KeyOfValue,
> typename _Compare, typename _ValueAlloc>
> friend class _Rb_tree;
>
> template<typename _Key2, typename _Value2, typename _ValueAlloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> friend class _Hashtable;
> };
>
>
> template<typename _Value, typename _NodeAlloc>
> class _Node_handle<_Value, _Value, _NodeAlloc>
> : public _Node_handle_common<_Value, _NodeAlloc>
> {
> public:
> constexpr _Node_handle() noexcept = default;
> ~_Node_handle() = default;
> _Node_handle(_Node_handle&&) noexcept = default;
>
> _Node_handle&
> operator=(_Node_handle&&) noexcept = default;
>
> using value_type = _Value;
>
> value_type&
> value() const noexcept
> {
> ;
> return *this->_M_ptr->_M_valptr();
> }
>
> void
> swap(_Node_handle& __nh) noexcept
> { this->_M_swap(__nh); }
>
> friend void
> swap(_Node_handle& __x, _Node_handle& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> private:
> using _AllocTraits = allocator_traits<_NodeAlloc>;
>
> _Node_handle(typename _AllocTraits::pointer __ptr,
> const _NodeAlloc& __alloc)
> : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { }
>
> const value_type&
> _M_key() const noexcept { return value(); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> friend class _Rb_tree;
>
> template<typename _Key2, typename _Value2, typename _ValueAlloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> friend class _Hashtable;
> };
>
>
> template<typename _Iterator, typename _NodeHandle>
> struct _Node_insert_return
> {
> _Iterator position = _Iterator();
> bool inserted = false;
> _NodeHandle node;
> };
>
>
>}
># 38 "/usr/include/c++/8/bits/hashtable.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, typename _Hash>
> using __cache_default
> = __not_<__and_<
> __is_fast_hash<_Hash>,
>
> __is_nothrow_invocable<const _Hash&, const _Tp&>>>;
># 169 "/usr/include/c++/8/bits/hashtable.h" 3
> template<typename _Key, typename _Value, typename _Alloc,
> typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash,
> typename _RehashPolicy, typename _Traits>
> class _Hashtable
> : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _Traits>,
> public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>,
> public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>,
> public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>,
> public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>,
> private __detail::_Hashtable_alloc<
> __alloc_rebind<_Alloc,
> __detail::_Hash_node<_Value,
> _Traits::__hash_cached::value>>>
> {
> static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
> "unordered container must have a non-const, non-volatile value_type");
>
> static_assert(is_same<typename _Alloc::value_type, _Value>{},
> "unordered container must have the same value_type as its allocator");
>
> static_assert(__is_invocable<const _H1&, const _Key&>{},
> "hash function must be invocable with an argument of key type");
> static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
> "key equality predicate must be invocable with two arguments of "
> "key type");
>
> using __traits_type = _Traits;
> using __hash_cached = typename __traits_type::__hash_cached;
> using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
> using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
>
> using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;
>
> using __value_alloc_traits =
> typename __hashtable_alloc::__value_alloc_traits;
> using __node_alloc_traits =
> typename __hashtable_alloc::__node_alloc_traits;
> using __node_base = typename __hashtable_alloc::__node_base;
> using __bucket_type = typename __hashtable_alloc::__bucket_type;
>
> public:
> typedef _Key key_type;
> typedef _Value value_type;
> typedef _Alloc allocator_type;
> typedef _Equal key_equal;
>
>
>
> typedef typename __value_alloc_traits::pointer pointer;
> typedef typename __value_alloc_traits::const_pointer const_pointer;
> typedef value_type& reference;
> typedef const value_type& const_reference;
>
> private:
> using __rehash_type = _RehashPolicy;
> using __rehash_state = typename __rehash_type::_State;
>
> using __constant_iterators = typename __traits_type::__constant_iterators;
> using __unique_keys = typename __traits_type::__unique_keys;
>
> using __key_extract = typename std::conditional<
> __constant_iterators::value,
> __detail::_Identity,
> __detail::_Select1st>::type;
>
> using __hashtable_base = __detail::
> _Hashtable_base<_Key, _Value, _ExtractKey,
> _Equal, _H1, _H2, _Hash, _Traits>;
>
> using __hash_code_base = typename __hashtable_base::__hash_code_base;
> using __hash_code = typename __hashtable_base::__hash_code;
> using __ireturn_type = typename __hashtable_base::__ireturn_type;
>
> using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
>
> using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
> _ExtractKey, _Equal,
> _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
>
> using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
> _Equal, _H1, _H2, _Hash,
> _RehashPolicy, _Traits>;
>
> using __reuse_or_alloc_node_type =
> __detail::_ReuseOrAllocNode<__node_alloc_type>;
>
>
> template<typename _Cond>
> using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>;
>
> template<typename _Cond>
> using __if_hash_not_cached = __or_<__hash_cached, _Cond>;
>
>
>
>
>
> struct __hash_code_base_access : __hash_code_base
> { using __hash_code_base::_M_bucket_index; };
>
>
>
> static_assert(noexcept(declval<const __hash_code_base_access&>()
> ._M_bucket_index((const __node_type*)nullptr,
> (std::size_t)0)),
> "Cache the hash code or qualify your functors involved"
> " in hash code and bucket index computation with noexcept");
>
>
>
>
>
>
> static_assert(__if_hash_cached<is_default_constructible<_H2>>::value,
> "Functor used to map hash code to bucket index"
> " must be default constructible");
>
> template<typename _Keya, typename _Valuea, typename _Alloca,
> typename _ExtractKeya, typename _Equala,
> typename _H1a, typename _H2a, typename _Hasha,
> typename _RehashPolicya, typename _Traitsa,
> bool _Unique_keysa>
> friend struct __detail::_Map_base;
>
> template<typename _Keya, typename _Valuea, typename _Alloca,
> typename _ExtractKeya, typename _Equala,
> typename _H1a, typename _H2a, typename _Hasha,
> typename _RehashPolicya, typename _Traitsa>
> friend struct __detail::_Insert_base;
>
> template<typename _Keya, typename _Valuea, typename _Alloca,
> typename _ExtractKeya, typename _Equala,
> typename _H1a, typename _H2a, typename _Hasha,
> typename _RehashPolicya, typename _Traitsa,
> bool _Constant_iteratorsa>
> friend struct __detail::_Insert;
>
> public:
> using size_type = typename __hashtable_base::size_type;
> using difference_type = typename __hashtable_base::difference_type;
>
> using iterator = typename __hashtable_base::iterator;
> using const_iterator = typename __hashtable_base::const_iterator;
>
> using local_iterator = typename __hashtable_base::local_iterator;
> using const_local_iterator = typename __hashtable_base::
> const_local_iterator;
>
>
> using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
> using insert_return_type = _Node_insert_return<iterator, node_type>;
>
>
> private:
> __bucket_type* _M_buckets = &_M_single_bucket;
> size_type _M_bucket_count = 1;
> __node_base _M_before_begin;
> size_type _M_element_count = 0;
> _RehashPolicy _M_rehash_policy;
>
>
>
>
>
>
>
> __bucket_type _M_single_bucket = nullptr;
>
> bool
> _M_uses_single_bucket(__bucket_type* __bkts) const
> { return __builtin_expect(__bkts == &_M_single_bucket, false); }
>
> bool
> _M_uses_single_bucket() const
> { return _M_uses_single_bucket(_M_buckets); }
>
> __hashtable_alloc&
> _M_base_alloc() { return *this; }
>
> __bucket_type*
> _M_allocate_buckets(size_type __n)
> {
> if (__builtin_expect(__n == 1, false))
> {
> _M_single_bucket = nullptr;
> return &_M_single_bucket;
> }
>
> return __hashtable_alloc::_M_allocate_buckets(__n);
> }
>
> void
> _M_deallocate_buckets(__bucket_type* __bkts, size_type __n)
> {
> if (_M_uses_single_bucket(__bkts))
> return;
>
> __hashtable_alloc::_M_deallocate_buckets(__bkts, __n);
> }
>
> void
> _M_deallocate_buckets()
> { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }
>
>
>
> __node_type*
> _M_bucket_begin(size_type __bkt) const;
>
> __node_type*
> _M_begin() const
> { return static_cast<__node_type*>(_M_before_begin._M_nxt); }
>
> template<typename _NodeGenerator>
> void
> _M_assign(const _Hashtable&, const _NodeGenerator&);
>
> void
> _M_move_assign(_Hashtable&&, std::true_type);
>
> void
> _M_move_assign(_Hashtable&&, std::false_type);
>
> void
> _M_reset() noexcept;
>
> _Hashtable(const _H1& __h1, const _H2& __h2, const _Hash& __h,
> const _Equal& __eq, const _ExtractKey& __exk,
> const allocator_type& __a)
> : __hashtable_base(__exk, __h1, __h2, __h, __eq),
> __hashtable_alloc(__node_alloc_type(__a))
> { }
>
> public:
>
> _Hashtable() = default;
> _Hashtable(size_type __bucket_hint,
> const _H1&, const _H2&, const _Hash&,
> const _Equal&, const _ExtractKey&,
> const allocator_type&);
>
> template<typename _InputIterator>
> _Hashtable(_InputIterator __first, _InputIterator __last,
> size_type __bucket_hint,
> const _H1&, const _H2&, const _Hash&,
> const _Equal&, const _ExtractKey&,
> const allocator_type&);
>
> _Hashtable(const _Hashtable&);
>
> _Hashtable(_Hashtable&&) noexcept;
>
> _Hashtable(const _Hashtable&, const allocator_type&);
>
> _Hashtable(_Hashtable&&, const allocator_type&);
>
>
> explicit
> _Hashtable(const allocator_type& __a)
> : __hashtable_alloc(__node_alloc_type(__a))
> { }
>
> explicit
> _Hashtable(size_type __n,
> const _H1& __hf = _H1(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _Hashtable(__n, __hf, _H2(), _Hash(), __eql,
> __key_extract(), __a)
> { }
>
> template<typename _InputIterator>
> _Hashtable(_InputIterator __f, _InputIterator __l,
> size_type __n = 0,
> const _H1& __hf = _H1(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _Hashtable(__f, __l, __n, __hf, _H2(), _Hash(), __eql,
> __key_extract(), __a)
> { }
>
> _Hashtable(initializer_list<value_type> __l,
> size_type __n = 0,
> const _H1& __hf = _H1(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _Hashtable(__l.begin(), __l.end(), __n, __hf, _H2(), _Hash(), __eql,
> __key_extract(), __a)
> { }
>
> _Hashtable&
> operator=(const _Hashtable& __ht);
>
> _Hashtable&
> operator=(_Hashtable&& __ht)
> noexcept(__node_alloc_traits::_S_nothrow_move()
> && is_nothrow_move_assignable<_H1>::value
> && is_nothrow_move_assignable<_Equal>::value)
> {
> constexpr bool __move_storage =
> __node_alloc_traits::_S_propagate_on_move_assign()
> || __node_alloc_traits::_S_always_equal();
> _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
> return *this;
> }
>
> _Hashtable&
> operator=(initializer_list<value_type> __l)
> {
> __reuse_or_alloc_node_type __roan(_M_begin(), *this);
> _M_before_begin._M_nxt = nullptr;
> clear();
> this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys());
> return *this;
> }
>
> ~_Hashtable() noexcept;
>
> void
> swap(_Hashtable&)
> noexcept(__and_<__is_nothrow_swappable<_H1>,
> __is_nothrow_swappable<_Equal>>::value);
>
>
> iterator
> begin() noexcept
> { return iterator(_M_begin()); }
>
> const_iterator
> begin() const noexcept
> { return const_iterator(_M_begin()); }
>
> iterator
> end() noexcept
> { return iterator(nullptr); }
>
> const_iterator
> end() const noexcept
> { return const_iterator(nullptr); }
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(_M_begin()); }
>
> const_iterator
> cend() const noexcept
> { return const_iterator(nullptr); }
>
> size_type
> size() const noexcept
> { return _M_element_count; }
>
> 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 __n) const
> { return std::distance(begin(__n), end(__n)); }
>
> size_type
> bucket(const key_type& __k) const
> { return _M_bucket_index(__k, this->_M_hash_code(__k)); }
>
> local_iterator
> begin(size_type __n)
> {
> return local_iterator(*this, _M_bucket_begin(__n),
> __n, _M_bucket_count);
> }
>
> local_iterator
> end(size_type __n)
> { return local_iterator(*this, nullptr, __n, _M_bucket_count); }
>
> const_local_iterator
> begin(size_type __n) const
> {
> return const_local_iterator(*this, _M_bucket_begin(__n),
> __n, _M_bucket_count);
> }
>
> const_local_iterator
> end(size_type __n) const
> { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); }
>
>
> const_local_iterator
> cbegin(size_type __n) const
> {
> return const_local_iterator(*this, _M_bucket_begin(__n),
> __n, _M_bucket_count);
> }
>
> const_local_iterator
> cend(size_type __n) const
> { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); }
>
> float
> load_factor() const noexcept
> {
> return static_cast<float>(size()) / static_cast<float>(bucket_count());
> }
>
>
>
>
>
>
> const _RehashPolicy&
> __rehash_policy() const
> { return _M_rehash_policy; }
>
> void
> __rehash_policy(const _RehashPolicy& __pol)
> { _M_rehash_policy = __pol; }
>
>
> iterator
> find(const key_type& __k);
>
> const_iterator
> find(const key_type& __k) const;
>
> size_type
> count(const key_type& __k) const;
>
> std::pair<iterator, iterator>
> equal_range(const key_type& __k);
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __k) const;
>
> protected:
>
> size_type
> _M_bucket_index(__node_type* __n) const noexcept
> { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }
>
> size_type
> _M_bucket_index(const key_type& __k, __hash_code __c) const
> { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); }
>
>
>
> __node_base*
> _M_find_before_node(size_type, const key_type&, __hash_code) const;
>
> __node_type*
> _M_find_node(size_type __bkt, const key_type& __key,
> __hash_code __c) const
> {
> __node_base* __before_n = _M_find_before_node(__bkt, __key, __c);
> if (__before_n)
> return static_cast<__node_type*>(__before_n->_M_nxt);
> return nullptr;
> }
>
>
> void
> _M_insert_bucket_begin(size_type, __node_type*);
>
>
> void
> _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n,
> size_type __next_bkt);
>
>
> __node_base*
> _M_get_previous_node(size_type __bkt, __node_base* __n);
>
>
>
>
> iterator
> _M_insert_unique_node(size_type __bkt, __hash_code __code,
> __node_type* __n, size_type __n_elt = 1);
>
>
>
> iterator
> _M_insert_multi_node(__node_type* __hint,
> __hash_code __code, __node_type* __n);
>
> template<typename... _Args>
> std::pair<iterator, bool>
> _M_emplace(std::true_type, _Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace(std::false_type __uk, _Args&&... __args)
> { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }
>
>
> template<typename... _Args>
> iterator
> _M_emplace(const_iterator, std::true_type __uk, _Args&&... __args)
> { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }
>
> template<typename... _Args>
> iterator
> _M_emplace(const_iterator, std::false_type, _Args&&... __args);
>
> template<typename _Arg, typename _NodeGenerator>
> std::pair<iterator, bool>
> _M_insert(_Arg&&, const _NodeGenerator&, true_type, size_type = 1);
>
> template<typename _Arg, typename _NodeGenerator>
> iterator
> _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
> false_type __uk)
> {
> return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen,
> __uk);
> }
>
>
> template<typename _Arg, typename _NodeGenerator>
> iterator
> _M_insert(const_iterator, _Arg&& __arg,
> const _NodeGenerator& __node_gen, true_type __uk)
> {
> return
> _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first;
> }
>
>
> template<typename _Arg, typename _NodeGenerator>
> iterator
> _M_insert(const_iterator, _Arg&&,
> const _NodeGenerator&, false_type);
>
> size_type
> _M_erase(std::true_type, const key_type&);
>
> size_type
> _M_erase(std::false_type, const key_type&);
>
> iterator
> _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);
>
> public:
>
> template<typename... _Args>
> __ireturn_type
> emplace(_Args&&... __args)
> { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); }
>
> template<typename... _Args>
> iterator
> emplace_hint(const_iterator __hint, _Args&&... __args)
> {
> return _M_emplace(__hint, __unique_keys(),
> std::forward<_Args>(__args)...);
> }
>
>
>
>
> iterator
> erase(const_iterator);
>
>
> iterator
> erase(iterator __it)
> { return erase(const_iterator(__it)); }
>
> size_type
> erase(const key_type& __k)
> { return _M_erase(__unique_keys(), __k); }
>
> iterator
> erase(const_iterator, const_iterator);
>
> void
> clear() noexcept;
>
>
> void rehash(size_type __n);
>
>
>
>
>
>
> insert_return_type
> _M_reinsert_node(node_type&& __nh)
> {
> insert_return_type __ret;
> if (__nh.empty())
> __ret.position = end();
> else
> {
> ;
>
> const key_type& __k = __nh._M_key();
> __hash_code __code = this->_M_hash_code(__k);
> size_type __bkt = _M_bucket_index(__k, __code);
> if (__node_type* __n = _M_find_node(__bkt, __k, __code))
> {
> __ret.node = std::move(__nh);
> __ret.position = iterator(__n);
> __ret.inserted = false;
> }
> else
> {
> __ret.position
> = _M_insert_unique_node(__bkt, __code, __nh._M_ptr);
> __nh._M_ptr = nullptr;
> __ret.inserted = true;
> }
> }
> return __ret;
> }
>
>
> iterator
> _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh)
> {
> iterator __ret;
> if (__nh.empty())
> __ret = end();
> else
> {
> ;
>
> auto __code = this->_M_hash_code(__nh._M_key());
> auto __node = std::exchange(__nh._M_ptr, nullptr);
>
> __ret = _M_insert_multi_node(__hint._M_cur, __code, __node);
> }
> return __ret;
> }
>
>
> node_type
> extract(const_iterator __pos)
> {
> __node_type* __n = __pos._M_cur;
> size_t __bkt = _M_bucket_index(__n);
>
>
>
>
> __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
>
> 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() };
> }
>
>
> node_type
> extract(const _Key& __k)
> {
> node_type __nh;
> auto __pos = find(__k);
> if (__pos != end())
> __nh = extract(const_iterator(__pos));
> return __nh;
> }
>
>
> template<typename _Compatible_Hashtable>
> void
> _M_merge_unique(_Compatible_Hashtable& __src) noexcept
> {
> static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
> node_type>, "Node types are compatible");
> ;
>
> auto __n_elt = __src.size();
> for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
> {
> auto __pos = __i++;
> const key_type& __k = this->_M_extract()(__pos._M_cur->_M_v());
> __hash_code __code = this->_M_hash_code(__k);
> size_type __bkt = _M_bucket_index(__k, __code);
> if (_M_find_node(__bkt, __k, __code) == nullptr)
> {
> auto __nh = __src.extract(__pos);
> _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt);
> __nh._M_ptr = nullptr;
> __n_elt = 1;
> }
> else if (__n_elt != 1)
> --__n_elt;
> }
> }
>
>
> template<typename _Compatible_Hashtable>
> void
> _M_merge_multi(_Compatible_Hashtable& __src) noexcept
> {
> static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
> node_type>, "Node types are compatible");
> ;
>
> this->reserve(size() + __src.size());
> for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
> _M_reinsert_node_multi(cend(), __src.extract(__i++));
> }
>
>
> private:
>
> void _M_rehash_aux(size_type __n, std::true_type);
>
>
> void _M_rehash_aux(size_type __n, std::false_type);
>
>
>
> void _M_rehash(size_type __n, const __rehash_state& __state);
> };
>
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_bucket_begin(size_type __bkt) const
> -> __node_type*
> {
> __node_base* __n = _M_buckets[__bkt];
> return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _Hashtable(size_type __bucket_hint,
> const _H1& __h1, const _H2& __h2, const _Hash& __h,
> const _Equal& __eq, const _ExtractKey& __exk,
> const allocator_type& __a)
> : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
> {
> auto __bkt = _M_rehash_policy._M_next_bkt(__bucket_hint);
> if (__bkt > _M_bucket_count)
> {
> _M_buckets = _M_allocate_buckets(__bkt);
> _M_bucket_count = __bkt;
> }
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> template<typename _InputIterator>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _Hashtable(_InputIterator __f, _InputIterator __l,
> size_type __bucket_hint,
> const _H1& __h1, const _H2& __h2, const _Hash& __h,
> const _Equal& __eq, const _ExtractKey& __exk,
> const allocator_type& __a)
> : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
> {
> auto __nb_elems = __detail::__distance_fw(__f, __l);
> auto __bkt_count =
> _M_rehash_policy._M_next_bkt(
> std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
> __bucket_hint));
>
> if (__bkt_count > _M_bucket_count)
> {
> _M_buckets = _M_allocate_buckets(__bkt_count);
> _M_bucket_count = __bkt_count;
> }
>
> for (; __f != __l; ++__f)
> this->insert(*__f);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> operator=(const _Hashtable& __ht)
> -> _Hashtable&
> {
> if (&__ht == this)
> return *this;
>
> if (__node_alloc_traits::_S_propagate_on_copy_assign())
> {
> auto& __this_alloc = this->_M_node_allocator();
> auto& __that_alloc = __ht._M_node_allocator();
> if (!__node_alloc_traits::_S_always_equal()
> && __this_alloc != __that_alloc)
> {
>
> this->_M_deallocate_nodes(_M_begin());
> _M_before_begin._M_nxt = nullptr;
> _M_deallocate_buckets();
> _M_buckets = nullptr;
> std::__alloc_on_copy(__this_alloc, __that_alloc);
> __hashtable_base::operator=(__ht);
> _M_bucket_count = __ht._M_bucket_count;
> _M_element_count = __ht._M_element_count;
> _M_rehash_policy = __ht._M_rehash_policy;
> try
> {
> _M_assign(__ht,
> [this](const __node_type* __n)
> { return this->_M_allocate_node(__n->_M_v()); });
> }
> catch(...)
> {
>
>
> _M_reset();
> throw;
> }
> return *this;
> }
> std::__alloc_on_copy(__this_alloc, __that_alloc);
> }
>
>
> __bucket_type* __former_buckets = nullptr;
> std::size_t __former_bucket_count = _M_bucket_count;
> const __rehash_state& __former_state = _M_rehash_policy._M_state();
>
> if (_M_bucket_count != __ht._M_bucket_count)
> {
> __former_buckets = _M_buckets;
> _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
> _M_bucket_count = __ht._M_bucket_count;
> }
> else
> __builtin_memset(_M_buckets, 0,
> _M_bucket_count * sizeof(__bucket_type));
>
> try
> {
> __hashtable_base::operator=(__ht);
> _M_element_count = __ht._M_element_count;
> _M_rehash_policy = __ht._M_rehash_policy;
> __reuse_or_alloc_node_type __roan(_M_begin(), *this);
> _M_before_begin._M_nxt = nullptr;
> _M_assign(__ht,
> [&__roan](const __node_type* __n)
> { return __roan(__n->_M_v()); });
> if (__former_buckets)
> _M_deallocate_buckets(__former_buckets, __former_bucket_count);
> }
> catch(...)
> {
> if (__former_buckets)
> {
>
> _M_deallocate_buckets();
> _M_rehash_policy._M_reset(__former_state);
> _M_buckets = __former_buckets;
> _M_bucket_count = __former_bucket_count;
> }
> __builtin_memset(_M_buckets, 0,
> _M_bucket_count * sizeof(__bucket_type));
> throw;
> }
> return *this;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> template<typename _NodeGenerator>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_assign(const _Hashtable& __ht, const _NodeGenerator& __node_gen)
> {
> __bucket_type* __buckets = nullptr;
> if (!_M_buckets)
> _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);
>
> try
> {
> if (!__ht._M_before_begin._M_nxt)
> return;
>
>
>
> __node_type* __ht_n = __ht._M_begin();
> __node_type* __this_n = __node_gen(__ht_n);
> this->_M_copy_code(__this_n, __ht_n);
> _M_before_begin._M_nxt = __this_n;
> _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin;
>
>
> __node_base* __prev_n = __this_n;
> for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
> {
> __this_n = __node_gen(__ht_n);
> __prev_n->_M_nxt = __this_n;
> this->_M_copy_code(__this_n, __ht_n);
> size_type __bkt = _M_bucket_index(__this_n);
> if (!_M_buckets[__bkt])
> _M_buckets[__bkt] = __prev_n;
> __prev_n = __this_n;
> }
> }
> catch(...)
> {
> clear();
> if (__buckets)
> _M_deallocate_buckets();
> throw;
> }
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_reset() noexcept
> {
> _M_rehash_policy._M_reset();
> _M_bucket_count = 1;
> _M_single_bucket = nullptr;
> _M_buckets = &_M_single_bucket;
> _M_before_begin._M_nxt = nullptr;
> _M_element_count = 0;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_move_assign(_Hashtable&& __ht, std::true_type)
> {
> this->_M_deallocate_nodes(_M_begin());
> _M_deallocate_buckets();
> __hashtable_base::operator=(std::move(__ht));
> _M_rehash_policy = __ht._M_rehash_policy;
> if (!__ht._M_uses_single_bucket())
> _M_buckets = __ht._M_buckets;
> else
> {
> _M_buckets = &_M_single_bucket;
> _M_single_bucket = __ht._M_single_bucket;
> }
> _M_bucket_count = __ht._M_bucket_count;
> _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
> _M_element_count = __ht._M_element_count;
> std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());
>
>
>
> if (_M_begin())
> _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
> __ht._M_reset();
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_move_assign(_Hashtable&& __ht, std::false_type)
> {
> if (__ht._M_node_allocator() == this->_M_node_allocator())
> _M_move_assign(std::move(__ht), std::true_type());
> else
> {
>
> __bucket_type* __former_buckets = nullptr;
> size_type __former_bucket_count = _M_bucket_count;
> const __rehash_state& __former_state = _M_rehash_policy._M_state();
>
> if (_M_bucket_count != __ht._M_bucket_count)
> {
> __former_buckets = _M_buckets;
> _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
> _M_bucket_count = __ht._M_bucket_count;
> }
> else
> __builtin_memset(_M_buckets, 0,
> _M_bucket_count * sizeof(__bucket_type));
>
> try
> {
> __hashtable_base::operator=(std::move(__ht));
> _M_element_count = __ht._M_element_count;
> _M_rehash_policy = __ht._M_rehash_policy;
> __reuse_or_alloc_node_type __roan(_M_begin(), *this);
> _M_before_begin._M_nxt = nullptr;
> _M_assign(__ht,
> [&__roan](__node_type* __n)
> { return __roan(std::move_if_noexcept(__n->_M_v())); });
> __ht.clear();
> }
> catch(...)
> {
> if (__former_buckets)
> {
> _M_deallocate_buckets();
> _M_rehash_policy._M_reset(__former_state);
> _M_buckets = __former_buckets;
> _M_bucket_count = __former_bucket_count;
> }
> __builtin_memset(_M_buckets, 0,
> _M_bucket_count * sizeof(__bucket_type));
> throw;
> }
> }
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _Hashtable(const _Hashtable& __ht)
> : __hashtable_base(__ht),
> __map_base(__ht),
> __rehash_base(__ht),
> __hashtable_alloc(
> __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
> _M_buckets(nullptr),
> _M_bucket_count(__ht._M_bucket_count),
> _M_element_count(__ht._M_element_count),
> _M_rehash_policy(__ht._M_rehash_policy)
> {
> _M_assign(__ht,
> [this](const __node_type* __n)
> { return this->_M_allocate_node(__n->_M_v()); });
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _Hashtable(_Hashtable&& __ht) noexcept
> : __hashtable_base(__ht),
> __map_base(__ht),
> __rehash_base(__ht),
> __hashtable_alloc(std::move(__ht._M_base_alloc())),
> _M_buckets(__ht._M_buckets),
> _M_bucket_count(__ht._M_bucket_count),
> _M_before_begin(__ht._M_before_begin._M_nxt),
> _M_element_count(__ht._M_element_count),
> _M_rehash_policy(__ht._M_rehash_policy)
> {
>
> if (__ht._M_uses_single_bucket())
> {
> _M_buckets = &_M_single_bucket;
> _M_single_bucket = __ht._M_single_bucket;
> }
>
>
>
> if (_M_begin())
> _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
>
> __ht._M_reset();
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
> : __hashtable_base(__ht),
> __map_base(__ht),
> __rehash_base(__ht),
> __hashtable_alloc(__node_alloc_type(__a)),
> _M_buckets(),
> _M_bucket_count(__ht._M_bucket_count),
> _M_element_count(__ht._M_element_count),
> _M_rehash_policy(__ht._M_rehash_policy)
> {
> _M_assign(__ht,
> [this](const __node_type* __n)
> { return this->_M_allocate_node(__n->_M_v()); });
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
> : __hashtable_base(__ht),
> __map_base(__ht),
> __rehash_base(__ht),
> __hashtable_alloc(__node_alloc_type(__a)),
> _M_buckets(nullptr),
> _M_bucket_count(__ht._M_bucket_count),
> _M_element_count(__ht._M_element_count),
> _M_rehash_policy(__ht._M_rehash_policy)
> {
> if (__ht._M_node_allocator() == this->_M_node_allocator())
> {
> if (__ht._M_uses_single_bucket())
> {
> _M_buckets = &_M_single_bucket;
> _M_single_bucket = __ht._M_single_bucket;
> }
> else
> _M_buckets = __ht._M_buckets;
>
> _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
>
>
> if (_M_begin())
> _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
> __ht._M_reset();
> }
> else
> {
> _M_assign(__ht,
> [this](__node_type* __n)
> {
> return this->_M_allocate_node(
> std::move_if_noexcept(__n->_M_v()));
> });
> __ht.clear();
> }
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> ~_Hashtable() noexcept
> {
> clear();
> _M_deallocate_buckets();
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> swap(_Hashtable& __x)
> noexcept(__and_<__is_nothrow_swappable<_H1>,
> __is_nothrow_swappable<_Equal>>::value)
> {
>
>
>
> this->_M_swap(__x);
>
> std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator());
> std::swap(_M_rehash_policy, __x._M_rehash_policy);
>
>
> if (this->_M_uses_single_bucket())
> {
> if (!__x._M_uses_single_bucket())
> {
> _M_buckets = __x._M_buckets;
> __x._M_buckets = &__x._M_single_bucket;
> }
> }
> else if (__x._M_uses_single_bucket())
> {
> __x._M_buckets = _M_buckets;
> _M_buckets = &_M_single_bucket;
> }
> else
> std::swap(_M_buckets, __x._M_buckets);
>
> std::swap(_M_bucket_count, __x._M_bucket_count);
> std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
> std::swap(_M_element_count, __x._M_element_count);
> std::swap(_M_single_bucket, __x._M_single_bucket);
>
>
>
> if (_M_begin())
> _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
>
> if (__x._M_begin())
> __x._M_buckets[__x._M_bucket_index(__x._M_begin())]
> = &__x._M_before_begin;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> find(const key_type& __k)
> -> iterator
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __n = _M_bucket_index(__k, __code);
> __node_type* __p = _M_find_node(__n, __k, __code);
> return __p ? iterator(__p) : end();
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> find(const key_type& __k) const
> -> const_iterator
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __n = _M_bucket_index(__k, __code);
> __node_type* __p = _M_find_node(__n, __k, __code);
> return __p ? const_iterator(__p) : end();
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> count(const key_type& __k) const
> -> size_type
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __n = _M_bucket_index(__k, __code);
> __node_type* __p = _M_bucket_begin(__n);
> if (!__p)
> return 0;
>
> std::size_t __result = 0;
> for (;; __p = __p->_M_next())
> {
> if (this->_M_equals(__k, __code, __p))
> ++__result;
> else if (__result)
>
>
>
> break;
> if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n)
> break;
> }
> return __result;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> equal_range(const key_type& __k)
> -> pair<iterator, iterator>
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __n = _M_bucket_index(__k, __code);
> __node_type* __p = _M_find_node(__n, __k, __code);
>
> if (__p)
> {
> __node_type* __p1 = __p->_M_next();
> while (__p1 && _M_bucket_index(__p1) == __n
> && this->_M_equals(__k, __code, __p1))
> __p1 = __p1->_M_next();
>
> return std::make_pair(iterator(__p), iterator(__p1));
> }
> else
> return std::make_pair(end(), end());
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> equal_range(const key_type& __k) const
> -> pair<const_iterator, const_iterator>
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __n = _M_bucket_index(__k, __code);
> __node_type* __p = _M_find_node(__n, __k, __code);
>
> if (__p)
> {
> __node_type* __p1 = __p->_M_next();
> while (__p1 && _M_bucket_index(__p1) == __n
> && this->_M_equals(__k, __code, __p1))
> __p1 = __p1->_M_next();
>
> return std::make_pair(const_iterator(__p), const_iterator(__p1));
> }
> else
> return std::make_pair(end(), end());
> }
>
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_find_before_node(size_type __n, const key_type& __k,
> __hash_code __code) const
> -> __node_base*
> {
> __node_base* __prev_p = _M_buckets[__n];
> if (!__prev_p)
> return nullptr;
>
> for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);;
> __p = __p->_M_next())
> {
> if (this->_M_equals(__k, __code, __p))
> return __prev_p;
>
> if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n)
> break;
> __prev_p = __p;
> }
> return nullptr;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_insert_bucket_begin(size_type __bkt, __node_type* __node)
> {
> if (_M_buckets[__bkt])
> {
>
>
> __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
> _M_buckets[__bkt]->_M_nxt = __node;
> }
> else
> {
>
>
>
> __node->_M_nxt = _M_before_begin._M_nxt;
> _M_before_begin._M_nxt = __node;
> if (__node->_M_nxt)
>
>
> _M_buckets[_M_bucket_index(__node->_M_next())] = __node;
> _M_buckets[__bkt] = &_M_before_begin;
> }
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_remove_bucket_begin(size_type __bkt, __node_type* __next,
> size_type __next_bkt)
> {
> if (!__next || __next_bkt != __bkt)
> {
>
>
> if (__next)
> _M_buckets[__next_bkt] = _M_buckets[__bkt];
>
>
> if (&_M_before_begin == _M_buckets[__bkt])
> _M_before_begin._M_nxt = __next;
> _M_buckets[__bkt] = nullptr;
> }
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_get_previous_node(size_type __bkt, __node_base* __n)
> -> __node_base*
> {
> __node_base* __prev_n = _M_buckets[__bkt];
> while (__prev_n->_M_nxt != __n)
> __prev_n = __prev_n->_M_nxt;
> return __prev_n;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> template<typename... _Args>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_emplace(std::true_type, _Args&&... __args)
> -> pair<iterator, bool>
> {
>
> __node_type* __node = this->_M_allocate_node(std::forward<_Args>(__args)...);
> const key_type& __k = this->_M_extract()(__node->_M_v());
> __hash_code __code;
> try
> {
> __code = this->_M_hash_code(__k);
> }
> catch(...)
> {
> this->_M_deallocate_node(__node);
> throw;
> }
>
> size_type __bkt = _M_bucket_index(__k, __code);
> if (__node_type* __p = _M_find_node(__bkt, __k, __code))
> {
>
> this->_M_deallocate_node(__node);
> return std::make_pair(iterator(__p), false);
> }
>
>
> return std::make_pair(_M_insert_unique_node(__bkt, __code, __node),
> true);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> template<typename... _Args>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_emplace(const_iterator __hint, std::false_type, _Args&&... __args)
> -> iterator
> {
>
> __node_type* __node =
> this->_M_allocate_node(std::forward<_Args>(__args)...);
>
> __hash_code __code;
> try
> {
> __code = this->_M_hash_code(this->_M_extract()(__node->_M_v()));
> }
> catch(...)
> {
> this->_M_deallocate_node(__node);
> throw;
> }
>
> return _M_insert_multi_node(__hint._M_cur, __code, __node);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_insert_unique_node(size_type __bkt, __hash_code __code,
> __node_type* __node, size_type __n_elt)
> -> iterator
> {
> const __rehash_state& __saved_state = _M_rehash_policy._M_state();
> std::pair<bool, std::size_t> __do_rehash
> = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
> __n_elt);
>
> try
> {
> if (__do_rehash.first)
> {
> _M_rehash(__do_rehash.second, __saved_state);
> __bkt = _M_bucket_index(this->_M_extract()(__node->_M_v()), __code);
> }
>
> this->_M_store_code(__node, __code);
>
>
> _M_insert_bucket_begin(__bkt, __node);
> ++_M_element_count;
> return iterator(__node);
> }
> catch(...)
> {
> this->_M_deallocate_node(__node);
> throw;
> }
> }
>
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_insert_multi_node(__node_type* __hint, __hash_code __code,
> __node_type* __node)
> -> iterator
> {
> const __rehash_state& __saved_state = _M_rehash_policy._M_state();
> std::pair<bool, std::size_t> __do_rehash
> = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);
>
> try
> {
> if (__do_rehash.first)
> _M_rehash(__do_rehash.second, __saved_state);
>
> this->_M_store_code(__node, __code);
> const key_type& __k = this->_M_extract()(__node->_M_v());
> size_type __bkt = _M_bucket_index(__k, __code);
>
>
>
> __node_base* __prev
> = __builtin_expect(__hint != nullptr, false)
> && this->_M_equals(__k, __code, __hint)
> ? __hint
> : _M_find_before_node(__bkt, __k, __code);
> if (__prev)
> {
>
> __node->_M_nxt = __prev->_M_nxt;
> __prev->_M_nxt = __node;
> if (__builtin_expect(__prev == __hint, false))
>
>
> if (__node->_M_nxt
> && !this->_M_equals(__k, __code, __node->_M_next()))
> {
> size_type __next_bkt = _M_bucket_index(__node->_M_next());
> if (__next_bkt != __bkt)
> _M_buckets[__next_bkt] = __node;
> }
> }
> else
>
>
>
>
> _M_insert_bucket_begin(__bkt, __node);
> ++_M_element_count;
> return iterator(__node);
> }
> catch(...)
> {
> this->_M_deallocate_node(__node);
> throw;
> }
> }
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> template<typename _Arg, typename _NodeGenerator>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, true_type,
> size_type __n_elt)
> -> pair<iterator, bool>
> {
> const key_type& __k = this->_M_extract()(__v);
> __hash_code __code = this->_M_hash_code(__k);
> size_type __bkt = _M_bucket_index(__k, __code);
>
> __node_type* __n = _M_find_node(__bkt, __k, __code);
> if (__n)
> return std::make_pair(iterator(__n), false);
>
> __n = __node_gen(std::forward<_Arg>(__v));
> return { _M_insert_unique_node(__bkt, __code, __n, __n_elt), true };
> }
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> template<typename _Arg, typename _NodeGenerator>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_insert(const_iterator __hint, _Arg&& __v,
> const _NodeGenerator& __node_gen, false_type)
> -> iterator
> {
>
>
> __hash_code __code = this->_M_hash_code(this->_M_extract()(__v));
>
>
> __node_type* __node = __node_gen(std::forward<_Arg>(__v));
>
> return _M_insert_multi_node(__hint._M_cur, __code, __node);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> erase(const_iterator __it)
> -> iterator
> {
> __node_type* __n = __it._M_cur;
> std::size_t __bkt = _M_bucket_index(__n);
>
>
>
>
> __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
> return _M_erase(__bkt, __prev_n, __n);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n)
> -> iterator
> {
> if (__prev_n == _M_buckets[__bkt])
> _M_remove_bucket_begin(__bkt, __n->_M_next(),
> __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
> else if (__n->_M_nxt)
> {
> size_type __next_bkt = _M_bucket_index(__n->_M_next());
> if (__next_bkt != __bkt)
> _M_buckets[__next_bkt] = __prev_n;
> }
>
> __prev_n->_M_nxt = __n->_M_nxt;
> iterator __result(__n->_M_next());
> this->_M_deallocate_node(__n);
> --_M_element_count;
>
> return __result;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_erase(std::true_type, const key_type& __k)
> -> size_type
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __bkt = _M_bucket_index(__k, __code);
>
>
> __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
> if (!__prev_n)
> return 0;
>
>
> __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
> _M_erase(__bkt, __prev_n, __n);
> return 1;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_erase(std::false_type, const key_type& __k)
> -> size_type
> {
> __hash_code __code = this->_M_hash_code(__k);
> std::size_t __bkt = _M_bucket_index(__k, __code);
>
>
> __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
> if (!__prev_n)
> return 0;
>
>
>
>
>
>
>
> __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
> __node_type* __n_last = __n;
> std::size_t __n_last_bkt = __bkt;
> do
> {
> __n_last = __n_last->_M_next();
> if (!__n_last)
> break;
> __n_last_bkt = _M_bucket_index(__n_last);
> }
> while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last));
>
>
> size_type __result = 0;
> do
> {
> __node_type* __p = __n->_M_next();
> this->_M_deallocate_node(__n);
> __n = __p;
> ++__result;
> --_M_element_count;
> }
> while (__n != __n_last);
>
> if (__prev_n == _M_buckets[__bkt])
> _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
> else if (__n_last && __n_last_bkt != __bkt)
> _M_buckets[__n_last_bkt] = __prev_n;
> __prev_n->_M_nxt = __n_last;
> return __result;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> auto
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> erase(const_iterator __first, const_iterator __last)
> -> iterator
> {
> __node_type* __n = __first._M_cur;
> __node_type* __last_n = __last._M_cur;
> if (__n == __last_n)
> return iterator(__n);
>
> std::size_t __bkt = _M_bucket_index(__n);
>
> __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
> bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
> std::size_t __n_bkt = __bkt;
> for (;;)
> {
> do
> {
> __node_type* __tmp = __n;
> __n = __n->_M_next();
> this->_M_deallocate_node(__tmp);
> --_M_element_count;
> if (!__n)
> break;
> __n_bkt = _M_bucket_index(__n);
> }
> while (__n != __last_n && __n_bkt == __bkt);
> if (__is_bucket_begin)
> _M_remove_bucket_begin(__bkt, __n, __n_bkt);
> if (__n == __last_n)
> break;
> __is_bucket_begin = true;
> __bkt = __n_bkt;
> }
>
> if (__n && (__n_bkt != __bkt || __is_bucket_begin))
> _M_buckets[__n_bkt] = __prev_n;
> __prev_n->_M_nxt = __n;
> return iterator(__n);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> clear() noexcept
> {
> this->_M_deallocate_nodes(_M_begin());
> __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type));
> _M_element_count = 0;
> _M_before_begin._M_nxt = nullptr;
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> rehash(size_type __n)
> {
> const __rehash_state& __saved_state = _M_rehash_policy._M_state();
> std::size_t __buckets
> = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
> __n);
> __buckets = _M_rehash_policy._M_next_bkt(__buckets);
>
> if (__buckets != _M_bucket_count)
> _M_rehash(__buckets, __saved_state);
> else
>
> _M_rehash_policy._M_reset(__saved_state);
> }
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_rehash(size_type __n, const __rehash_state& __state)
> {
> try
> {
> _M_rehash_aux(__n, __unique_keys());
> }
> catch(...)
> {
>
>
> _M_rehash_policy._M_reset(__state);
> throw;
> }
> }
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_rehash_aux(size_type __n, std::true_type)
> {
> __bucket_type* __new_buckets = _M_allocate_buckets(__n);
> __node_type* __p = _M_begin();
> _M_before_begin._M_nxt = nullptr;
> std::size_t __bbegin_bkt = 0;
> while (__p)
> {
> __node_type* __next = __p->_M_next();
> std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n);
> 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 = __n;
> _M_buckets = __new_buckets;
> }
>
>
>
> template<typename _Key, typename _Value,
> typename _Alloc, typename _ExtractKey, typename _Equal,
> typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
> typename _Traits>
> void
> _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
> _H1, _H2, _Hash, _RehashPolicy, _Traits>::
> _M_rehash_aux(size_type __n, std::false_type)
> {
> __bucket_type* __new_buckets = _M_allocate_buckets(__n);
>
> __node_type* __p = _M_begin();
> _M_before_begin._M_nxt = nullptr;
> std::size_t __bbegin_bkt = 0;
> std::size_t __prev_bkt = 0;
> __node_type* __prev_p = nullptr;
> bool __check_bucket = false;
>
> while (__p)
> {
> __node_type* __next = __p->_M_next();
> std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n);
>
> 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(),
> __n);
> 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(), __n);
> if (__next_bkt != __prev_bkt)
> __new_buckets[__next_bkt] = __prev_p;
> }
>
> _M_deallocate_buckets();
> _M_bucket_count = __n;
> _M_buckets = __new_buckets;
> }
>
>
> template<typename, typename, typename> class _Hash_merge_helper { };
>
>
>
>}
># 47 "/usr/include/c++/8/unordered_map" 2 3
># 1 "/usr/include/c++/8/bits/unordered_map.h" 1 3
># 33 "/usr/include/c++/8/bits/unordered_map.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<bool _Cache>
> using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;
>
> template<typename _Key,
> typename _Tp,
> typename _Hash = hash<_Key>,
> typename _Pred = std::equal_to<_Key>,
> typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
> typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
> using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
> _Alloc, __detail::_Select1st,
> _Pred, _Hash,
> __detail::_Mod_range_hashing,
> __detail::_Default_ranged_hash,
> __detail::_Prime_rehash_policy, _Tr>;
>
>
> template<bool _Cache>
> using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
>
> template<typename _Key,
> typename _Tp,
> typename _Hash = hash<_Key>,
> typename _Pred = std::equal_to<_Key>,
> typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
> typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
> using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
> _Alloc, __detail::_Select1st,
> _Pred, _Hash,
> __detail::_Mod_range_hashing,
> __detail::_Default_ranged_hash,
> __detail::_Prime_rehash_policy, _Tr>;
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> class unordered_multimap;
># 98 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename _Key, typename _Tp,
> typename _Hash = hash<_Key>,
> typename _Pred = equal_to<_Key>,
> typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
> class unordered_map
> {
> typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
> _Hashtable _M_h;
>
> public:
>
>
>
> typedef typename _Hashtable::key_type key_type;
> typedef typename _Hashtable::value_type value_type;
> typedef typename _Hashtable::mapped_type mapped_type;
> typedef typename _Hashtable::hasher hasher;
> typedef typename _Hashtable::key_equal key_equal;
> typedef typename _Hashtable::allocator_type allocator_type;
>
>
>
>
> typedef typename _Hashtable::pointer pointer;
> typedef typename _Hashtable::const_pointer const_pointer;
> typedef typename _Hashtable::reference reference;
> typedef typename _Hashtable::const_reference const_reference;
> typedef typename _Hashtable::iterator iterator;
> typedef typename _Hashtable::const_iterator const_iterator;
> typedef typename _Hashtable::local_iterator local_iterator;
> typedef typename _Hashtable::const_local_iterator const_local_iterator;
> typedef typename _Hashtable::size_type size_type;
> typedef typename _Hashtable::difference_type difference_type;
>
>
>
> using node_type = typename _Hashtable::node_type;
> using insert_return_type = typename _Hashtable::insert_return_type;
>
>
>
>
>
> unordered_map() = default;
># 150 "/usr/include/c++/8/bits/unordered_map.h" 3
> explicit
> unordered_map(size_type __n,
> const hasher& __hf = hasher(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _M_h(__n, __hf, __eql, __a)
> { }
># 171 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename _InputIterator>
> unordered_map(_InputIterator __first, _InputIterator __last,
> size_type __n = 0,
> const hasher& __hf = hasher(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _M_h(__first, __last, __n, __hf, __eql, __a)
> { }
>
>
> unordered_map(const unordered_map&) = default;
>
>
> unordered_map(unordered_map&&) = default;
>
>
>
>
>
> explicit
> unordered_map(const allocator_type& __a)
> : _M_h(__a)
> { }
>
>
>
>
>
>
> unordered_map(const unordered_map& __umap,
> const allocator_type& __a)
> : _M_h(__umap._M_h, __a)
> { }
>
>
>
>
>
>
> unordered_map(unordered_map&& __umap,
> const allocator_type& __a)
> : _M_h(std::move(__umap._M_h), __a)
> { }
># 226 "/usr/include/c++/8/bits/unordered_map.h" 3
> unordered_map(initializer_list<value_type> __l,
> size_type __n = 0,
> const hasher& __hf = hasher(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _M_h(__l, __n, __hf, __eql, __a)
> { }
>
> unordered_map(size_type __n, const allocator_type& __a)
> : unordered_map(__n, hasher(), key_equal(), __a)
> { }
>
> unordered_map(size_type __n, const hasher& __hf,
> const allocator_type& __a)
> : unordered_map(__n, __hf, key_equal(), __a)
> { }
>
> template<typename _InputIterator>
> unordered_map(_InputIterator __first, _InputIterator __last,
> size_type __n,
> const allocator_type& __a)
> : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
> { }
>
> template<typename _InputIterator>
> unordered_map(_InputIterator __first, _InputIterator __last,
> size_type __n, const hasher& __hf,
> const allocator_type& __a)
> : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
> { }
>
> unordered_map(initializer_list<value_type> __l,
> size_type __n,
> const allocator_type& __a)
> : unordered_map(__l, __n, hasher(), key_equal(), __a)
> { }
>
> unordered_map(initializer_list<value_type> __l,
> size_type __n, const hasher& __hf,
> const allocator_type& __a)
> : unordered_map(__l, __n, __hf, key_equal(), __a)
> { }
>
>
> unordered_map&
> operator=(const unordered_map&) = default;
>
>
> unordered_map&
> operator=(unordered_map&&) = default;
># 288 "/usr/include/c++/8/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(); }
>
>
>
>
> bool
> empty() const noexcept
> { return _M_h.empty(); }
>
>
> size_type
> size() const noexcept
> { return _M_h.size(); }
>
>
> size_type
> max_size() const noexcept
> { return _M_h.max_size(); }
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return _M_h.begin(); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return _M_h.begin(); }
>
> const_iterator
> cbegin() const noexcept
> { return _M_h.begin(); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return _M_h.end(); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return _M_h.end(); }
>
> const_iterator
> cend() const noexcept
> { return _M_h.end(); }
># 385 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename... _Args>
> std::pair<iterator, bool>
> emplace(_Args&&... __args)
> { return _M_h.emplace(std::forward<_Args>(__args)...); }
># 416 "/usr/include/c++/8/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)
> {
> ;
> return _M_h.extract(__pos);
> }
>
>
> node_type
> extract(const key_type& __key)
> { return _M_h.extract(__key); }
>
>
> insert_return_type
> insert(node_type&& __nh)
> { return _M_h._M_reinsert_node(std::move(__nh)); }
>
>
> iterator
> insert(const_iterator, node_type&& __nh)
> { return _M_h._M_reinsert_node(std::move(__nh)).position; }
># 468 "/usr/include/c++/8/bits/unordered_map.h" 3
> template <typename... _Args>
> pair<iterator, bool>
> try_emplace(const key_type& __k, _Args&&... __args)
> {
> iterator __i = find(__k);
> if (__i == end())
> {
> __i = emplace(std::piecewise_construct,
> std::forward_as_tuple(__k),
> std::forward_as_tuple(
> std::forward<_Args>(__args)...))
> .first;
> return {__i, true};
> }
> return {__i, false};
> }
>
>
> template <typename... _Args>
> pair<iterator, bool>
> try_emplace(key_type&& __k, _Args&&... __args)
> {
> iterator __i = find(__k);
> if (__i == end())
> {
> __i = emplace(std::piecewise_construct,
> std::forward_as_tuple(std::move(__k)),
> std::forward_as_tuple(
> std::forward<_Args>(__args)...))
> .first;
> return {__i, true};
> }
> return {__i, false};
> }
># 531 "/usr/include/c++/8/bits/unordered_map.h" 3
> template <typename... _Args>
> iterator
> try_emplace(const_iterator __hint, const key_type& __k,
> _Args&&... __args)
> {
> iterator __i = find(__k);
> if (__i == end())
> __i = emplace_hint(__hint, std::piecewise_construct,
> std::forward_as_tuple(__k),
> std::forward_as_tuple(
> std::forward<_Args>(__args)...));
> return __i;
> }
>
>
> template <typename... _Args>
> iterator
> try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
> {
> iterator __i = find(__k);
> if (__i == end())
> __i = emplace_hint(__hint, std::piecewise_construct,
> std::forward_as_tuple(std::move(__k)),
> std::forward_as_tuple(
> std::forward<_Args>(__args)...));
> return __i;
> }
># 578 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> std::pair<iterator, bool>
> insert(_Pair&& __x)
> { return _M_h.insert(std::forward<_Pair>(__x)); }
># 618 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(const_iterator __hint, _Pair&& __x)
> { return _M_h.insert(__hint, std::forward<_Pair>(__x)); }
># 645 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_h.insert(__first, __last); }
># 657 "/usr/include/c++/8/bits/unordered_map.h" 3
> void
> insert(initializer_list<value_type> __l)
> { _M_h.insert(__l); }
># 684 "/usr/include/c++/8/bits/unordered_map.h" 3
> template <typename _Obj>
> pair<iterator, bool>
> insert_or_assign(const key_type& __k, _Obj&& __obj)
> {
> iterator __i = find(__k);
> if (__i == end())
> {
> __i = emplace(std::piecewise_construct,
> std::forward_as_tuple(__k),
> std::forward_as_tuple(std::forward<_Obj>(__obj)))
> .first;
> return {__i, true};
> }
> (*__i).second = std::forward<_Obj>(__obj);
> return {__i, false};
> }
>
>
> template <typename _Obj>
> pair<iterator, bool>
> insert_or_assign(key_type&& __k, _Obj&& __obj)
> {
> iterator __i = find(__k);
> if (__i == end())
> {
> __i = emplace(std::piecewise_construct,
> std::forward_as_tuple(std::move(__k)),
> std::forward_as_tuple(std::forward<_Obj>(__obj)))
> .first;
> return {__i, true};
> }
> (*__i).second = std::forward<_Obj>(__obj);
> return {__i, false};
> }
># 745 "/usr/include/c++/8/bits/unordered_map.h" 3
> template <typename _Obj>
> iterator
> insert_or_assign(const_iterator __hint, const key_type& __k,
> _Obj&& __obj)
> {
> iterator __i = find(__k);
> if (__i == end())
> {
> return emplace_hint(__hint, std::piecewise_construct,
> std::forward_as_tuple(__k),
> std::forward_as_tuple(
> std::forward<_Obj>(__obj)));
> }
> (*__i).second = std::forward<_Obj>(__obj);
> return __i;
> }
>
>
> template <typename _Obj>
> iterator
> insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
> {
> iterator __i = find(__k);
> if (__i == end())
> {
> return emplace_hint(__hint, std::piecewise_construct,
> std::forward_as_tuple(std::move(__k)),
> std::forward_as_tuple(
> std::forward<_Obj>(__obj)));
> }
> (*__i).second = std::forward<_Obj>(__obj);
> return __i;
> }
># 794 "/usr/include/c++/8/bits/unordered_map.h" 3
> iterator
> erase(const_iterator __position)
> { return _M_h.erase(__position); }
>
>
> iterator
> erase(iterator __position)
> { return _M_h.erase(__position); }
># 816 "/usr/include/c++/8/bits/unordered_map.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_h.erase(__x); }
># 834 "/usr/include/c++/8/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(); }
># 858 "/usr/include/c++/8/bits/unordered_map.h" 3
> void
> swap(unordered_map& __x)
> noexcept( noexcept(_M_h.swap(__x._M_h)) )
> { _M_h.swap(__x._M_h); }
>
>
> template<typename, typename, typename>
> friend class std::_Hash_merge_helper;
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
> {
> using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
> _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
> }
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
> { merge(__source); }
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
> {
> using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
> _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
> }
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
> { merge(__source); }
>
>
>
>
>
>
> hasher
> hash_function() const
> { return _M_h.hash_function(); }
>
>
>
> key_equal
> key_eq() const
> { return _M_h.key_eq(); }
># 922 "/usr/include/c++/8/bits/unordered_map.h" 3
> iterator
> find(const key_type& __x)
> { return _M_h.find(__x); }
>
> const_iterator
> find(const key_type& __x) const
> { return _M_h.find(__x); }
># 940 "/usr/include/c++/8/bits/unordered_map.h" 3
> size_type
> count(const key_type& __x) const
> { return _M_h.count(__x); }
># 953 "/usr/include/c++/8/bits/unordered_map.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_h.equal_range(__x); }
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_h.equal_range(__x); }
># 975 "/usr/include/c++/8/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)]; }
># 992 "/usr/include/c++/8/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); }
># 1048 "/usr/include/c++/8/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); }
># 1063 "/usr/include/c++/8/bits/unordered_map.h" 3
> local_iterator
> end(size_type __n)
> { return _M_h.end(__n); }
># 1074 "/usr/include/c++/8/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); }
># 1111 "/usr/include/c++/8/bits/unordered_map.h" 3
> void
> rehash(size_type __n)
> { _M_h.rehash(__n); }
># 1122 "/usr/include/c++/8/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 = _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 = _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 = _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 = _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>;
># 1232 "/usr/include/c++/8/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;
># 1283 "/usr/include/c++/8/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)
> { }
># 1304 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename _InputIterator>
> unordered_multimap(_InputIterator __first, _InputIterator __last,
> size_type __n = 0,
> const hasher& __hf = hasher(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _M_h(__first, __last, __n, __hf, __eql, __a)
> { }
>
>
> unordered_multimap(const unordered_multimap&) = default;
>
>
> unordered_multimap(unordered_multimap&&) = default;
>
>
>
>
>
> explicit
> unordered_multimap(const allocator_type& __a)
> : _M_h(__a)
> { }
>
>
>
>
>
>
> unordered_multimap(const unordered_multimap& __ummap,
> const allocator_type& __a)
> : _M_h(__ummap._M_h, __a)
> { }
>
>
>
>
>
>
> unordered_multimap(unordered_multimap&& __ummap,
> const allocator_type& __a)
> : _M_h(std::move(__ummap._M_h), __a)
> { }
># 1359 "/usr/include/c++/8/bits/unordered_map.h" 3
> unordered_multimap(initializer_list<value_type> __l,
> size_type __n = 0,
> const hasher& __hf = hasher(),
> const key_equal& __eql = key_equal(),
> const allocator_type& __a = allocator_type())
> : _M_h(__l, __n, __hf, __eql, __a)
> { }
>
> unordered_multimap(size_type __n, const allocator_type& __a)
> : unordered_multimap(__n, hasher(), key_equal(), __a)
> { }
>
> unordered_multimap(size_type __n, const hasher& __hf,
> const allocator_type& __a)
> : unordered_multimap(__n, __hf, key_equal(), __a)
> { }
>
> template<typename _InputIterator>
> unordered_multimap(_InputIterator __first, _InputIterator __last,
> size_type __n,
> const allocator_type& __a)
> : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
> { }
>
> template<typename _InputIterator>
> unordered_multimap(_InputIterator __first, _InputIterator __last,
> size_type __n, const hasher& __hf,
> const allocator_type& __a)
> : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
> { }
>
> unordered_multimap(initializer_list<value_type> __l,
> size_type __n,
> const allocator_type& __a)
> : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
> { }
>
> unordered_multimap(initializer_list<value_type> __l,
> size_type __n, const hasher& __hf,
> const allocator_type& __a)
> : unordered_multimap(__l, __n, __hf, key_equal(), __a)
> { }
>
>
> unordered_multimap&
> operator=(const unordered_multimap&) = default;
>
>
> unordered_multimap&
> operator=(unordered_multimap&&) = default;
># 1421 "/usr/include/c++/8/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(); }
>
>
>
>
> 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(); }
># 1513 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename... _Args>
> iterator
> emplace(_Args&&... __args)
> { return _M_h.emplace(std::forward<_Args>(__args)...); }
># 1540 "/usr/include/c++/8/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)...); }
># 1555 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(_Pair&& __x)
> { return _M_h.insert(std::forward<_Pair>(__x)); }
># 1591 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(const_iterator __hint, _Pair&& __x)
> { return _M_h.insert(__hint, std::forward<_Pair>(__x)); }
># 1618 "/usr/include/c++/8/bits/unordered_map.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_h.insert(__first, __last); }
># 1631 "/usr/include/c++/8/bits/unordered_map.h" 3
> void
> insert(initializer_list<value_type> __l)
> { _M_h.insert(__l); }
>
>
>
> node_type
> extract(const_iterator __pos)
> {
> ;
> return _M_h.extract(__pos);
> }
>
>
> node_type
> extract(const key_type& __key)
> { return _M_h.extract(__key); }
>
>
> iterator
> insert(node_type&& __nh)
> { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); }
>
>
> iterator
> insert(const_iterator __hint, node_type&& __nh)
> { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); }
># 1674 "/usr/include/c++/8/bits/unordered_map.h" 3
> iterator
> erase(const_iterator __position)
> { return _M_h.erase(__position); }
>
>
> iterator
> erase(iterator __position)
> { return _M_h.erase(__position); }
># 1695 "/usr/include/c++/8/bits/unordered_map.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_h.erase(__x); }
># 1714 "/usr/include/c++/8/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(); }
># 1738 "/usr/include/c++/8/bits/unordered_map.h" 3
> void
> swap(unordered_multimap& __x)
> noexcept( noexcept(_M_h.swap(__x._M_h)) )
> { _M_h.swap(__x._M_h); }
>
>
> template<typename, typename, typename>
> friend class std::_Hash_merge_helper;
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
> {
> using _Merge_helper
> = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
> _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
> }
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
> { merge(__source); }
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
> {
> using _Merge_helper
> = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
> _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
> }
>
> template<typename _H2, typename _P2>
> void
> merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
> { merge(__source); }
>
>
>
>
>
>
> hasher
> hash_function() const
> { return _M_h.hash_function(); }
>
>
>
> key_equal
> key_eq() const
> { return _M_h.key_eq(); }
># 1804 "/usr/include/c++/8/bits/unordered_map.h" 3
> iterator
> find(const key_type& __x)
> { return _M_h.find(__x); }
>
> const_iterator
> find(const key_type& __x) const
> { return _M_h.find(__x); }
>
>
>
>
>
>
>
> size_type
> count(const key_type& __x) const
> { return _M_h.count(__x); }
># 1829 "/usr/include/c++/8/bits/unordered_map.h" 3
> std::pair<iterator, iterator>
> equal_range(const key_type& __x)
> { return _M_h.equal_range(__x); }
>
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_h.equal_range(__x); }
>
>
>
>
>
> size_type
> bucket_count() const noexcept
> { return _M_h.bucket_count(); }
>
>
> size_type
> max_bucket_count() const noexcept
> { return _M_h.max_bucket_count(); }
>
>
>
>
>
>
> size_type
> bucket_size(size_type __n) const
> { return _M_h.bucket_size(__n); }
>
>
>
>
>
>
> size_type
> bucket(const key_type& __key) const
> { return _M_h.bucket(__key); }
>
>
>
>
>
>
>
> local_iterator
> begin(size_type __n)
> { return _M_h.begin(__n); }
># 1885 "/usr/include/c++/8/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); }
># 1900 "/usr/include/c++/8/bits/unordered_map.h" 3
> local_iterator
> end(size_type __n)
> { return _M_h.end(__n); }
># 1911 "/usr/include/c++/8/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); }
># 1948 "/usr/include/c++/8/bits/unordered_map.h" 3
> void
> rehash(size_type __n)
> { _M_h.rehash(__n); }
># 1959 "/usr/include/c++/8/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 = _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 = _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 = _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 = _RequireAllocator<_Allocator>>
> unordered_multimap(initializer_list<pair<_Key, _Tp>>,
> unordered_multimap<int, int>::size_type,
> _Hash, _Allocator)
> -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
>
>
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> inline void
> swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
> unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> inline void
> swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> inline bool
> operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
> const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
> { return __x._M_h._M_equal(__y._M_h); }
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> inline bool
> operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
> const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
> { return !(__x == __y); }
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> inline bool
> operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
> const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
> { return __x._M_h._M_equal(__y._M_h); }
>
> template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
> inline bool
> operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
> const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
> { return !(__x == __y); }
>
>
>
>
>
> template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
> typename _Alloc, typename _Hash2, typename _Eq2>
> struct _Hash_merge_helper<
> std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>,
> _Hash2, _Eq2>
> {
> private:
> template<typename... _Tp>
> using unordered_map = std::unordered_map<_Tp...>;
> template<typename... _Tp>
> using unordered_multimap = std::unordered_multimap<_Tp...>;
>
> friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>;
>
> static auto&
> _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
> { return __map._M_h; }
>
> static auto&
> _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
> { return __map._M_h; }
> };
>
>
> template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
> typename _Alloc, typename _Hash2, typename _Eq2>
> struct _Hash_merge_helper<
> std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>,
> _Hash2, _Eq2>
> {
> private:
> template<typename... _Tp>
> using unordered_map = std::unordered_map<_Tp...>;
> template<typename... _Tp>
> using unordered_multimap = std::unordered_multimap<_Tp...>;
>
> friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>;
>
> static auto&
> _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
> { return __map._M_h; }
>
> static auto&
> _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
> { return __map._M_h; }
> };
>
>
>
>}
># 48 "/usr/include/c++/8/unordered_map" 2 3
># 62 "/usr/include/c++/8/functional" 2 3
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> template<typename _Callable, typename... _Args>
> inline invoke_result_t<_Callable, _Args...>
> invoke(_Callable&& __fn, _Args&&... __args)
> noexcept(is_nothrow_invocable_v<_Callable, _Args...>)
> {
> return std::__invoke(std::forward<_Callable>(__fn),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _MemFunPtr,
> bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
> class _Mem_fn_base
> : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
> {
> using _Traits = _Mem_fn_traits<_MemFunPtr>;
>
> using _Arity = typename _Traits::__arity;
> using _Varargs = typename _Traits::__vararg;
>
> template<typename _Func, typename... _BoundArgs>
> friend struct _Bind_check_arity;
>
> _MemFunPtr _M_pmf;
>
> public:
>
> using result_type = typename _Traits::__result_type;
>
> explicit constexpr
> _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
>
> template<typename... _Args>
> auto
> operator()(_Args&&... __args) const
> noexcept(noexcept(
> std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
> -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
> { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
> };
>
>
> template<typename _MemObjPtr>
> class _Mem_fn_base<_MemObjPtr, false>
> {
> using _Arity = integral_constant<size_t, 0>;
> using _Varargs = false_type;
>
> template<typename _Func, typename... _BoundArgs>
> friend struct _Bind_check_arity;
>
> _MemObjPtr _M_pm;
>
> public:
> explicit constexpr
> _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
>
> template<typename _Tp>
> auto
> operator()(_Tp&& __obj) const
> noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
> -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
> { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
> };
>
> template<typename _MemberPointer>
> struct _Mem_fn;
>
> template<typename _Res, typename _Class>
> struct _Mem_fn<_Res _Class::*>
> : _Mem_fn_base<_Res _Class::*>
> {
> using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
> };
># 158 "/usr/include/c++/8/functional" 3
> template<typename _Tp, typename _Class>
> inline _Mem_fn<_Tp _Class::*>
> mem_fn(_Tp _Class::* __pm) noexcept
> {
> return _Mem_fn<_Tp _Class::*>(__pm);
> }
># 173 "/usr/include/c++/8/functional" 3
> template<typename _Tp>
> struct is_bind_expression
> : public false_type { };
># 184 "/usr/include/c++/8/functional" 3
> template<typename _Tp>
> struct is_placeholder
> : public integral_constant<int, 0>
> { };
>
>
> template <typename _Tp> inline constexpr bool is_bind_expression_v
> = is_bind_expression<_Tp>::value;
> template <typename _Tp> inline constexpr int is_placeholder_v
> = is_placeholder<_Tp>::value;
>
>
>
>
>
> template<int _Num> struct _Placeholder { };
>
>
>
>
>
> namespace placeholders
> {
>
>
>
>
> extern const _Placeholder<1> _1;
> extern const _Placeholder<2> _2;
> extern const _Placeholder<3> _3;
> extern const _Placeholder<4> _4;
> extern const _Placeholder<5> _5;
> extern const _Placeholder<6> _6;
> extern const _Placeholder<7> _7;
> extern const _Placeholder<8> _8;
> extern const _Placeholder<9> _9;
> extern const _Placeholder<10> _10;
> extern const _Placeholder<11> _11;
> extern const _Placeholder<12> _12;
> extern const _Placeholder<13> _13;
> extern const _Placeholder<14> _14;
> extern const _Placeholder<15> _15;
> extern const _Placeholder<16> _16;
> extern const _Placeholder<17> _17;
> extern const _Placeholder<18> _18;
> extern const _Placeholder<19> _19;
> extern const _Placeholder<20> _20;
> extern const _Placeholder<21> _21;
> extern const _Placeholder<22> _22;
> extern const _Placeholder<23> _23;
> extern const _Placeholder<24> _24;
> extern const _Placeholder<25> _25;
> extern const _Placeholder<26> _26;
> extern const _Placeholder<27> _27;
> extern const _Placeholder<28> _28;
> extern const _Placeholder<29> _29;
> }
>
>
>
>
>
>
> template<int _Num>
> struct is_placeholder<_Placeholder<_Num> >
> : public integral_constant<int, _Num>
> { };
>
> template<int _Num>
> struct is_placeholder<const _Placeholder<_Num> >
> : public integral_constant<int, _Num>
> { };
>
>
>
> template<std::size_t __i, typename _Tuple>
> using _Safe_tuple_element_t
> = typename enable_if<(__i < tuple_size<_Tuple>::value),
> tuple_element<__i, _Tuple>>::type::type;
># 275 "/usr/include/c++/8/functional" 3
> template<typename _Arg,
> bool _IsBindExp = is_bind_expression<_Arg>::value,
> bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
> class _Mu;
>
>
>
>
>
>
> template<typename _Tp>
> class _Mu<reference_wrapper<_Tp>, false, false>
> {
> public:
>
>
>
>
> template<typename _CVRef, typename _Tuple>
> _Tp&
> operator()(_CVRef& __arg, _Tuple&) const volatile
> { return __arg.get(); }
> };
>
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, true, false>
> {
> public:
> template<typename _CVArg, typename... _Args>
> auto
> operator()(_CVArg& __arg,
> tuple<_Args...>& __tuple) const volatile
> -> decltype(__arg(declval<_Args>()...))
> {
>
> typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
> _Indexes;
> return this->__call(__arg, __tuple, _Indexes());
> }
>
> private:
>
>
> template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
> auto
> __call(_CVArg& __arg, tuple<_Args...>& __tuple,
> const _Index_tuple<_Indexes...>&) const volatile
> -> decltype(__arg(declval<_Args>()...))
> {
> return __arg(std::get<_Indexes>(std::move(__tuple))...);
> }
> };
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, false, true>
> {
> public:
> template<typename _Tuple>
> _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
> operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
> {
> return
> ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
> }
> };
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, false, false>
> {
> public:
> template<typename _CVArg, typename _Tuple>
> _CVArg&&
> operator()(_CVArg&& __arg, _Tuple&) const volatile
> { return std::forward<_CVArg>(__arg); }
> };
>
>
> template<std::size_t _Ind, typename... _Tp>
> inline auto
> __volget(volatile tuple<_Tp...>& __tuple)
> -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
> { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
>
>
> template<std::size_t _Ind, typename... _Tp>
> inline auto
> __volget(const volatile tuple<_Tp...>& __tuple)
> -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
> { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
>
>
> template<typename _Signature>
> struct _Bind;
>
> template<typename _Functor, typename... _Bound_args>
> class _Bind<_Functor(_Bound_args...)>
> : public _Weak_result_type<_Functor>
> {
> typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
> _Bound_indexes;
>
> _Functor _M_f;
> tuple<_Bound_args...> _M_bound_args;
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
> {
> return std::__invoke(_M_f,
> _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
> );
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
> {
> return std::__invoke(_M_f,
> _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
> );
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_v(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) volatile
> {
> return std::__invoke(_M_f,
> _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
> );
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_c_v(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) const volatile
> {
> return std::__invoke(_M_f,
> _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
> );
> }
>
> template<typename _BoundArg, typename _CallArgs>
> using _Mu_type = decltype(
> _Mu<typename remove_cv<_BoundArg>::type>()(
> std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );
>
> template<typename _Fn, typename _CallArgs, typename... _BArgs>
> using _Res_type_impl
> = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type;
>
> template<typename _CallArgs>
> using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;
>
> template<typename _CallArgs>
> using __dependent = typename
> enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;
>
> template<typename _CallArgs, template<class> class __cv_quals>
> using _Res_type_cv = _Res_type_impl<
> typename __cv_quals<__dependent<_CallArgs>>::type,
> _CallArgs,
> typename __cv_quals<_Bound_args>::type...>;
>
> public:
> template<typename... _Args>
> explicit _Bind(const _Functor& __f, _Args&&... __args)
> : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> template<typename... _Args>
> explicit _Bind(_Functor&& __f, _Args&&... __args)
> : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> _Bind(const _Bind&) = default;
>
> _Bind(_Bind&& __b)
> : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
> { }
>
>
> template<typename... _Args,
> typename _Result = _Res_type<tuple<_Args...>>>
> _Result
> operator()(_Args&&... __args)
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args,
> typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
> _Result
> operator()(_Args&&... __args) const
> {
> return this->__call_c<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
># 505 "/usr/include/c++/8/functional" 3
> template<typename... _Args,
> typename _Result = _Res_type_cv<tuple<_Args...>, add_volatile>>
> [[deprecated("std::bind does not support volatile in C++17")]]
> _Result
> operator()(_Args&&... __args) volatile
> {
> return this->__call_v<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args,
> typename _Result = _Res_type_cv<tuple<_Args...>, add_cv>>
> [[deprecated("std::bind does not support volatile in C++17")]]
> _Result
> operator()(_Args&&... __args) const volatile
> {
> return this->__call_c_v<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
> };
>
>
> template<typename _Result, typename _Signature>
> struct _Bind_result;
>
> template<typename _Result, typename _Functor, typename... _Bound_args>
> class _Bind_result<_Result, _Functor(_Bound_args...)>
> {
> typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
> _Bound_indexes;
>
> _Functor _M_f;
> tuple<_Bound_args...> _M_bound_args;
>
>
> template<typename _Res>
> using __enable_if_void
> = typename enable_if<is_void<_Res>{}>::type;
>
> template<typename _Res>
> using __disable_if_void
> = typename enable_if<!is_void<_Res>{}, _Result>::type;
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __disable_if_void<_Res>
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
> {
> return std::__invoke(_M_f, _Mu<_Bound_args>()
> (std::get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __enable_if_void<_Res>
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
> {
> std::__invoke(_M_f, _Mu<_Bound_args>()
> (std::get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __disable_if_void<_Res>
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
> {
> return std::__invoke(_M_f, _Mu<_Bound_args>()
> (std::get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __enable_if_void<_Res>
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
> {
> std::__invoke(_M_f, _Mu<_Bound_args>()
> (std::get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __disable_if_void<_Res>
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
> {
> return std::__invoke(_M_f, _Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __enable_if_void<_Res>
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
> {
> std::__invoke(_M_f, _Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __disable_if_void<_Res>
> __call(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) const volatile
> {
> return std::__invoke(_M_f, _Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> __enable_if_void<_Res>
> __call(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) const volatile
> {
> std::__invoke(_M_f, _Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
> public:
> typedef _Result result_type;
>
> template<typename... _Args>
> explicit _Bind_result(const _Functor& __f, _Args&&... __args)
> : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> template<typename... _Args>
> explicit _Bind_result(_Functor&& __f, _Args&&... __args)
> : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> _Bind_result(const _Bind_result&) = default;
>
> _Bind_result(_Bind_result&& __b)
> : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
> { }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args)
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) const
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> [[deprecated("std::bind does not support volatile in C++17")]]
> result_type
> operator()(_Args&&... __args) volatile
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> [[deprecated("std::bind does not support volatile in C++17")]]
> result_type
> operator()(_Args&&... __args) const volatile
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
> };
>
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<_Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<const _Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<volatile _Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<const volatile _Bind<_Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<_Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<const _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
> : public true_type { };
>
> template<typename _Func, typename... _BoundArgs>
> struct _Bind_check_arity { };
>
> template<typename _Ret, typename... _Args, typename... _BoundArgs>
> struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
> {
> static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
> "Wrong number of arguments for function");
> };
>
> template<typename _Ret, typename... _Args, typename... _BoundArgs>
> struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
> {
> static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
> "Wrong number of arguments for function");
> };
>
> template<typename _Tp, typename _Class, typename... _BoundArgs>
> struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
> {
> using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
> using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
> static_assert(_Varargs::value
> ? sizeof...(_BoundArgs) >= _Arity::value + 1
> : sizeof...(_BoundArgs) == _Arity::value + 1,
> "Wrong number of arguments for pointer-to-member");
> };
>
>
>
>
> template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
> using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
>
> template<bool _SocketLike, typename _Func, typename... _BoundArgs>
> struct _Bind_helper
> : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
> {
> typedef typename decay<_Func>::type __func_type;
> typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
> };
>
>
>
>
> template<typename _Func, typename... _BoundArgs>
> struct _Bind_helper<true, _Func, _BoundArgs...>
> { };
>
>
>
>
>
> template<typename _Func, typename... _BoundArgs>
> inline typename
> _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
> bind(_Func&& __f, _BoundArgs&&... __args)
> {
> typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
> return typename __helper_type::type(std::forward<_Func>(__f),
> std::forward<_BoundArgs>(__args)...);
> }
>
> template<typename _Result, typename _Func, typename... _BoundArgs>
> struct _Bindres_helper
> : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
> {
> typedef typename decay<_Func>::type __functor_type;
> typedef _Bind_result<_Result,
> __functor_type(typename decay<_BoundArgs>::type...)>
> type;
> };
>
>
>
>
>
> template<typename _Result, typename _Func, typename... _BoundArgs>
> inline
> typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
> bind(_Func&& __f, _BoundArgs&&... __args)
> {
> typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
> return typename __helper_type::type(std::forward<_Func>(__f),
> std::forward<_BoundArgs>(__args)...);
> }
>
>
>
> 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>
> _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;
># 872 "/usr/include/c++/8/functional" 3
> template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); }
> template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); }
> template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); }
> template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); }
>
>
> private:
> _Fn _M_fn;
> };
>
> template<typename _Tp, typename _Pred>
> struct __is_byte_like : false_type { };
>
> template<typename _Tp>
> struct __is_byte_like<_Tp, equal_to<_Tp>>
> : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
>
> template<typename _Tp>
> struct __is_byte_like<_Tp, equal_to<void>>
> : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
>
>
>
> enum class byte : unsigned char;
>
> template<>
> struct __is_byte_like<byte, equal_to<byte>>
> : true_type { };
>
> template<>
> struct __is_byte_like<byte, equal_to<void>>
> : true_type { };
>
>
>
> template<typename _Fn>
> inline auto
> not_fn(_Fn&& __fn)
> noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
> {
> return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
> }
>
>
>
>
> template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
> class default_searcher
> {
> public:
> default_searcher(_ForwardIterator1 __pat_first,
> _ForwardIterator1 __pat_last,
> _BinaryPredicate __pred = _BinaryPredicate())
> : _M_m(__pat_first, __pat_last, std::move(__pred))
> { }
>
> template<typename _ForwardIterator2>
> pair<_ForwardIterator2, _ForwardIterator2>
> operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const
> {
> _ForwardIterator2 __first_ret =
> std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m),
> std::get<2>(_M_m));
> auto __ret = std::make_pair(__first_ret, __first_ret);
> if (__ret.first != __last)
> std::advance(__ret.second, std::distance(std::get<0>(_M_m),
> std::get<1>(_M_m)));
> return __ret;
> }
>
> private:
> tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m;
> };
>
> template<typename _Key, typename _Tp, typename _Hash, typename _Pred>
> struct __boyer_moore_map_base
> {
> template<typename _RAIter>
> __boyer_moore_map_base(_RAIter __pat, size_t __patlen,
> _Hash&& __hf, _Pred&& __pred)
> : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
> {
> if (__patlen > 0)
> for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
> _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
> }
>
> using __diff_type = _Tp;
>
> __diff_type
> _M_lookup(_Key __key, __diff_type __not_found) const
> {
> auto __iter = _M_bad_char.find(__key);
> if (__iter == _M_bad_char.end())
> return __not_found;
> return __iter->second;
> }
>
> _Pred
> _M_pred() const { return _M_bad_char.key_eq(); }
>
> std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
> };
>
> template<typename _Tp, size_t _Len, typename _Pred>
> struct __boyer_moore_array_base
> {
> template<typename _RAIter, typename _Unused>
> __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
> _Unused&&, _Pred&& __pred)
> : _M_bad_char{ std::array<_Tp, _Len>{}, std::move(__pred) }
> {
> std::get<0>(_M_bad_char).fill(__patlen);
> if (__patlen > 0)
> for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
> {
> auto __ch = __pat[__i];
> using _UCh = make_unsigned_t<decltype(__ch)>;
> auto __uch = static_cast<_UCh>(__ch);
> std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i;
> }
> }
>
> using __diff_type = _Tp;
>
> template<typename _Key>
> __diff_type
> _M_lookup(_Key __key, __diff_type __not_found) const
> {
> auto __ukey = static_cast<make_unsigned_t<_Key>>(__key);
> if (__ukey >= _Len)
> return __not_found;
> return std::get<0>(_M_bad_char)[__ukey];
> }
>
> const _Pred&
> _M_pred() const { return std::get<1>(_M_bad_char); }
>
> tuple<std::array<_Tp, _Len>, _Pred> _M_bad_char;
> };
>
>
>
> template<typename _RAIter, typename _Hash, typename _Pred,
> typename _Val = typename iterator_traits<_RAIter>::value_type,
> typename _Diff = typename iterator_traits<_RAIter>::difference_type>
> using __boyer_moore_base_t
> = conditional_t<__is_byte_like<_Val, _Pred>::value,
> __boyer_moore_array_base<_Diff, 256, _Pred>,
> __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
>
> template<typename _RAIter, typename _Hash
> = hash<typename iterator_traits<_RAIter>::value_type>,
> typename _BinaryPredicate = equal_to<>>
> class boyer_moore_searcher
> : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
> {
> using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
> using typename _Base::__diff_type;
>
> public:
> boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
> _Hash __hf = _Hash(),
> _BinaryPredicate __pred = _BinaryPredicate());
>
> template<typename _RandomAccessIterator2>
> pair<_RandomAccessIterator2, _RandomAccessIterator2>
> operator()(_RandomAccessIterator2 __first,
> _RandomAccessIterator2 __last) const;
>
> private:
> bool
> _M_is_prefix(_RAIter __word, __diff_type __len,
> __diff_type __pos)
> {
> const auto& __pred = this->_M_pred();
> __diff_type __suffixlen = __len - __pos;
> for (__diff_type __i = 0; __i < __suffixlen; ++__i)
> if (!__pred(__word[__i], __word[__pos + __i]))
> return false;
> return true;
> }
>
> __diff_type
> _M_suffix_length(_RAIter __word, __diff_type __len,
> __diff_type __pos)
> {
> const auto& __pred = this->_M_pred();
> __diff_type __i = 0;
> while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
> && __i < __pos)
> {
> ++__i;
> }
> return __i;
> }
>
> template<typename _Tp>
> __diff_type
> _M_bad_char_shift(_Tp __c) const
> { return this->_M_lookup(__c, _M_pat_end - _M_pat); }
>
> _RAIter _M_pat;
> _RAIter _M_pat_end;
> std::vector<__diff_type> _M_good_suffix;
> };
>
> template<typename _RAIter, typename _Hash
> = hash<typename iterator_traits<_RAIter>::value_type>,
> typename _BinaryPredicate = equal_to<>>
> class boyer_moore_horspool_searcher
> : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
> {
> using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
> using typename _Base::__diff_type;
>
> public:
> boyer_moore_horspool_searcher(_RAIter __pat,
> _RAIter __pat_end,
> _Hash __hf = _Hash(),
> _BinaryPredicate __pred
> = _BinaryPredicate())
> : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
> _M_pat(__pat), _M_pat_end(__pat_end)
> { }
>
> template<typename _RandomAccessIterator2>
> pair<_RandomAccessIterator2, _RandomAccessIterator2>
> operator()(_RandomAccessIterator2 __first,
> _RandomAccessIterator2 __last) const
> {
> const auto& __pred = this->_M_pred();
> auto __patlen = _M_pat_end - _M_pat;
> if (__patlen == 0)
> return std::make_pair(__first, __first);
> auto __len = __last - __first;
> while (__len >= __patlen)
> {
> for (auto __scan = __patlen - 1;
> __pred(__first[__scan], _M_pat[__scan]); --__scan)
> if (__scan == 0)
> return std::make_pair(__first, __first + __patlen);
> auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
> __len -= __shift;
> __first += __shift;
> }
> return std::make_pair(__last, __last);
> }
>
> private:
> template<typename _Tp>
> __diff_type
> _M_bad_char_shift(_Tp __c) const
> { return this->_M_lookup(__c, _M_pat_end - _M_pat); }
>
> _RAIter _M_pat;
> _RAIter _M_pat_end;
> };
>
> template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
> boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
> boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
> _Hash __hf, _BinaryPredicate __pred)
> : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
> _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
> {
> auto __patlen = __pat_end - __pat;
> if (__patlen == 0)
> return;
> __diff_type __last_prefix = __patlen - 1;
> for (__diff_type __p = __patlen - 1; __p >= 0; --__p)
> {
> if (_M_is_prefix(__pat, __patlen, __p + 1))
> __last_prefix = __p + 1;
> _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
> }
> for (__diff_type __p = 0; __p < __patlen - 1; ++__p)
> {
> auto __slen = _M_suffix_length(__pat, __patlen, __p);
> auto __pos = __patlen - 1 - __slen;
> if (!__pred(__pat[__p - __slen], __pat[__pos]))
> _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
> }
> }
>
> template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
> template<typename _RandomAccessIterator2>
> pair<_RandomAccessIterator2, _RandomAccessIterator2>
> boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
> operator()(_RandomAccessIterator2 __first,
> _RandomAccessIterator2 __last) const
> {
> auto __patlen = _M_pat_end - _M_pat;
> if (__patlen == 0)
> return std::make_pair(__first, __first);
> const auto& __pred = this->_M_pred();
> __diff_type __i = __patlen - 1;
> auto __stringlen = __last - __first;
> while (__i < __stringlen)
> {
> __diff_type __j = __patlen - 1;
> while (__j >= 0 && __pred(__first[__i], _M_pat[__j]))
> {
> --__i;
> --__j;
> }
> if (__j < 0)
> {
> const auto __match = __first + __i + 1;
> return std::make_pair(__match, __match + __patlen);
> }
> __i += std::max(_M_bad_char_shift(__first[__i]),
> _M_good_suffix[__j]);
> }
> return std::make_pair(__last, __last);
> }
>
>
>
>
>
>}
># 33 "/usr/local/include/nghttp2/asio_http2.h" 2 3
># 1 "/usr/include/c++/8/map" 1 3
># 58 "/usr/include/c++/8/map" 3
> 
># 59 "/usr/include/c++/8/map" 3
>
># 1 "/usr/include/c++/8/bits/stl_tree.h" 1 3
># 61 "/usr/include/c++/8/bits/stl_tree.h" 3
> 
># 62 "/usr/include/c++/8/bits/stl_tree.h" 3
># 75 "/usr/include/c++/8/bits/stl_tree.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 99 "/usr/include/c++/8/bits/stl_tree.h" 3
> enum _Rb_tree_color { _S_red = false, _S_black = true };
>
> struct _Rb_tree_node_base
> {
> typedef _Rb_tree_node_base* _Base_ptr;
> typedef const _Rb_tree_node_base* _Const_Base_ptr;
>
> _Rb_tree_color _M_color;
> _Base_ptr _M_parent;
> _Base_ptr _M_left;
> _Base_ptr _M_right;
>
> static _Base_ptr
> _S_minimum(_Base_ptr __x) noexcept
> {
> while (__x->_M_left != 0) __x = __x->_M_left;
> return __x;
> }
>
> static _Const_Base_ptr
> _S_minimum(_Const_Base_ptr __x) noexcept
> {
> while (__x->_M_left != 0) __x = __x->_M_left;
> return __x;
> }
>
> static _Base_ptr
> _S_maximum(_Base_ptr __x) noexcept
> {
> while (__x->_M_right != 0) __x = __x->_M_right;
> return __x;
> }
>
> static _Const_Base_ptr
> _S_maximum(_Const_Base_ptr __x) noexcept
> {
> while (__x->_M_right != 0) __x = __x->_M_right;
> return __x;
> }
> };
>
>
> template<typename _Key_compare>
> struct _Rb_tree_key_compare
> {
> _Key_compare _M_key_compare;
>
> _Rb_tree_key_compare()
> noexcept(is_nothrow_default_constructible<_Key_compare>::value)
>
> : _M_key_compare()
> { }
>
> _Rb_tree_key_compare(const _Key_compare& __comp)
> : _M_key_compare(__comp)
> { }
>
>
>
> _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;
>
> _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
> noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
> : _M_key_compare(__x._M_key_compare)
> { }
>
> };
>
>
> struct _Rb_tree_header
> {
> _Rb_tree_node_base _M_header;
> size_t _M_node_count;
>
> _Rb_tree_header() noexcept
> {
> _M_header._M_color = _S_red;
> _M_reset();
> }
>
>
> _Rb_tree_header(_Rb_tree_header&& __x) noexcept
> {
> if (__x._M_header._M_parent != nullptr)
> _M_move_data(__x);
> else
> {
> _M_header._M_color = _S_red;
> _M_reset();
> }
> }
>
>
> void
> _M_move_data(_Rb_tree_header& __from)
> {
> _M_header._M_color = __from._M_header._M_color;
> _M_header._M_parent = __from._M_header._M_parent;
> _M_header._M_left = __from._M_header._M_left;
> _M_header._M_right = __from._M_header._M_right;
> _M_header._M_parent->_M_parent = &_M_header;
> _M_node_count = __from._M_node_count;
>
> __from._M_reset();
> }
>
> void
> _M_reset()
> {
> _M_header._M_parent = 0;
> _M_header._M_left = &_M_header;
> _M_header._M_right = &_M_header;
> _M_node_count = 0;
> }
> };
>
> template<typename _Val>
> struct _Rb_tree_node : public _Rb_tree_node_base
> {
> typedef _Rb_tree_node<_Val>* _Link_type;
># 231 "/usr/include/c++/8/bits/stl_tree.h" 3
> __gnu_cxx::__aligned_membuf<_Val> _M_storage;
>
> _Val*
> _M_valptr()
> { return _M_storage._M_ptr(); }
>
> const _Val*
> _M_valptr() const
> { return _M_storage._M_ptr(); }
>
> };
>
> __attribute__ ((__pure__)) _Rb_tree_node_base*
> _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
>
> __attribute__ ((__pure__)) const _Rb_tree_node_base*
> _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
>
> __attribute__ ((__pure__)) _Rb_tree_node_base*
> _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
>
> __attribute__ ((__pure__)) const _Rb_tree_node_base*
> _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
>
> template<typename _Tp>
> struct _Rb_tree_iterator
> {
> typedef _Tp value_type;
> typedef _Tp& reference;
> typedef _Tp* pointer;
>
> typedef bidirectional_iterator_tag iterator_category;
> typedef ptrdiff_t difference_type;
>
> typedef _Rb_tree_iterator<_Tp> _Self;
> typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
> typedef _Rb_tree_node<_Tp>* _Link_type;
>
> _Rb_tree_iterator() noexcept
> : _M_node() { }
>
> explicit
> _Rb_tree_iterator(_Base_ptr __x) noexcept
> : _M_node(__x) { }
>
> reference
> operator*() const noexcept
> { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
>
> pointer
> operator->() const noexcept
> { return static_cast<_Link_type> (_M_node)->_M_valptr(); }
>
> _Self&
> operator++() noexcept
> {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
> }
>
> _Self
> operator++(int) noexcept
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
> }
>
> _Self&
> operator--() noexcept
> {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
> }
>
> _Self
> operator--(int) noexcept
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const noexcept
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const noexcept
> { return _M_node != __x._M_node; }
>
> _Base_ptr _M_node;
> };
>
> template<typename _Tp>
> struct _Rb_tree_const_iterator
> {
> typedef _Tp value_type;
> typedef const _Tp& reference;
> typedef const _Tp* pointer;
>
> typedef _Rb_tree_iterator<_Tp> iterator;
>
> typedef bidirectional_iterator_tag iterator_category;
> typedef ptrdiff_t difference_type;
>
> typedef _Rb_tree_const_iterator<_Tp> _Self;
> typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
> typedef const _Rb_tree_node<_Tp>* _Link_type;
>
> _Rb_tree_const_iterator() noexcept
> : _M_node() { }
>
> explicit
> _Rb_tree_const_iterator(_Base_ptr __x) noexcept
> : _M_node(__x) { }
>
> _Rb_tree_const_iterator(const iterator& __it) noexcept
> : _M_node(__it._M_node) { }
>
> iterator
> _M_const_cast() const noexcept
> { return iterator(const_cast<typename iterator::_Base_ptr>(_M_node)); }
>
> reference
> operator*() const noexcept
> { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
>
> pointer
> operator->() const noexcept
> { return static_cast<_Link_type>(_M_node)->_M_valptr(); }
>
> _Self&
> operator++() noexcept
> {
> _M_node = _Rb_tree_increment(_M_node);
> return *this;
> }
>
> _Self
> operator++(int) noexcept
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_increment(_M_node);
> return __tmp;
> }
>
> _Self&
> operator--() noexcept
> {
> _M_node = _Rb_tree_decrement(_M_node);
> return *this;
> }
>
> _Self
> operator--(int) noexcept
> {
> _Self __tmp = *this;
> _M_node = _Rb_tree_decrement(_M_node);
> return __tmp;
> }
>
> bool
> operator==(const _Self& __x) const noexcept
> { return _M_node == __x._M_node; }
>
> bool
> operator!=(const _Self& __x) const noexcept
> { return _M_node != __x._M_node; }
>
> _Base_ptr _M_node;
> };
>
> template<typename _Val>
> inline bool
> operator==(const _Rb_tree_iterator<_Val>& __x,
> const _Rb_tree_const_iterator<_Val>& __y) noexcept
> { return __x._M_node == __y._M_node; }
>
> template<typename _Val>
> inline bool
> operator!=(const _Rb_tree_iterator<_Val>& __x,
> const _Rb_tree_const_iterator<_Val>& __y) noexcept
> { return __x._M_node != __y._M_node; }
>
> void
> _Rb_tree_insert_and_rebalance(const bool __insert_left,
> _Rb_tree_node_base* __x,
> _Rb_tree_node_base* __p,
> _Rb_tree_node_base& __header) throw ();
>
> _Rb_tree_node_base*
> _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
> _Rb_tree_node_base& __header) throw ();
>
>
> template<typename _Cmp, typename _SfinaeType, typename = __void_t<>>
> struct __has_is_transparent
> { };
>
> template<typename _Cmp, typename _SfinaeType>
> struct __has_is_transparent<_Cmp, _SfinaeType,
> __void_t<typename _Cmp::is_transparent>>
> { typedef void type; };
>
>
>
> template<typename _Tree1, typename _Cmp2>
> struct _Rb_tree_merge_helper { };
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc = allocator<_Val> >
> class _Rb_tree
> {
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
>
> typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;
>
>
> static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
> "comparison object must be invocable with two arguments of key type");
>
>
>
> static_assert(is_invocable_v<const _Compare&, const _Key&, const _Key&>,
> "comparison object must be invocable as const");
>
>
>
> protected:
> typedef _Rb_tree_node_base* _Base_ptr;
> typedef const _Rb_tree_node_base* _Const_Base_ptr;
> typedef _Rb_tree_node<_Val>* _Link_type;
> typedef const _Rb_tree_node<_Val>* _Const_Link_type;
>
> private:
>
>
> struct _Reuse_or_alloc_node
> {
> _Reuse_or_alloc_node(_Rb_tree& __t)
> : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
> {
> if (_M_root)
> {
> _M_root->_M_parent = 0;
>
> if (_M_nodes->_M_left)
> _M_nodes = _M_nodes->_M_left;
> }
> else
> _M_nodes = 0;
> }
>
>
> _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
>
>
> ~_Reuse_or_alloc_node()
> { _M_t._M_erase(static_cast<_Link_type>(_M_root)); }
>
> template<typename _Arg>
> _Link_type
>
>
>
> operator()(_Arg&& __arg)
>
> {
> _Link_type __node = static_cast<_Link_type>(_M_extract());
> if (__node)
> {
> _M_t._M_destroy_node(__node);
> _M_t._M_construct_node(__node, std::forward<_Arg>(__arg));
> return __node;
> }
>
> return _M_t._M_create_node(std::forward<_Arg>(__arg));
> }
>
> private:
> _Base_ptr
> _M_extract()
> {
> if (!_M_nodes)
> return _M_nodes;
>
> _Base_ptr __node = _M_nodes;
> _M_nodes = _M_nodes->_M_parent;
> if (_M_nodes)
> {
> if (_M_nodes->_M_right == __node)
> {
> _M_nodes->_M_right = 0;
>
> if (_M_nodes->_M_left)
> {
> _M_nodes = _M_nodes->_M_left;
>
> while (_M_nodes->_M_right)
> _M_nodes = _M_nodes->_M_right;
>
> if (_M_nodes->_M_left)
> _M_nodes = _M_nodes->_M_left;
> }
> }
> else
> _M_nodes->_M_left = 0;
> }
> else
> _M_root = 0;
>
> return __node;
> }
>
> _Base_ptr _M_root;
> _Base_ptr _M_nodes;
> _Rb_tree& _M_t;
> };
>
>
>
> struct _Alloc_node
> {
> _Alloc_node(_Rb_tree& __t)
> : _M_t(__t) { }
>
> template<typename _Arg>
> _Link_type
>
>
>
> operator()(_Arg&& __arg) const
>
> { return _M_t._M_create_node(std::forward<_Arg>(__arg)); }
>
> private:
> _Rb_tree& _M_t;
> };
>
> public:
> typedef _Key key_type;
> typedef _Val value_type;
> typedef value_type* pointer;
> typedef const value_type* const_pointer;
> typedef value_type& reference;
> typedef const value_type& const_reference;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> _Node_allocator&
> _M_get_Node_allocator() noexcept
> { return this->_M_impl; }
>
> const _Node_allocator&
> _M_get_Node_allocator() const noexcept
> { return this->_M_impl; }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Node_allocator()); }
>
> protected:
> _Link_type
> _M_get_node()
> { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }
>
> void
> _M_put_node(_Link_type __p) noexcept
> { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }
># 630 "/usr/include/c++/8/bits/stl_tree.h" 3
> template<typename... _Args>
> void
> _M_construct_node(_Link_type __node, _Args&&... __args)
> {
> try
> {
> ::new(__node) _Rb_tree_node<_Val>;
> _Alloc_traits::construct(_M_get_Node_allocator(),
> __node->_M_valptr(),
> std::forward<_Args>(__args)...);
> }
> catch(...)
> {
> __node->~_Rb_tree_node<_Val>();
> _M_put_node(__node);
> throw;
> }
> }
>
> template<typename... _Args>
> _Link_type
> _M_create_node(_Args&&... __args)
> {
> _Link_type __tmp = _M_get_node();
> _M_construct_node(__tmp, std::forward<_Args>(__args)...);
> return __tmp;
> }
>
> void
> _M_destroy_node(_Link_type __p) noexcept
> {
> _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
> __p->~_Rb_tree_node<_Val>();
> }
>
>
> void
> _M_drop_node(_Link_type __p) noexcept
> {
> _M_destroy_node(__p);
> _M_put_node(__p);
> }
>
> template<typename _NodeGen>
> _Link_type
> _M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen)
> {
> _Link_type __tmp = __node_gen(*__x->_M_valptr());
> __tmp->_M_color = __x->_M_color;
> __tmp->_M_left = 0;
> __tmp->_M_right = 0;
> return __tmp;
> }
>
> protected:
>
>
>
>
> template<typename _Key_compare,
> bool = __is_pod(_Key_compare)>
>
> struct _Rb_tree_impl
> : public _Node_allocator
> , public _Rb_tree_key_compare<_Key_compare>
> , public _Rb_tree_header
> {
> typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;
>
> _Rb_tree_impl()
> noexcept(is_nothrow_default_constructible<_Node_allocator>::value && is_nothrow_default_constructible<_Base_key_compare>::value)
>
>
> : _Node_allocator()
> { }
>
> _Rb_tree_impl(const _Rb_tree_impl& __x)
> : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
> , _Base_key_compare(__x._M_key_compare)
> { }
>
>
>
>
>
>
> _Rb_tree_impl(_Rb_tree_impl&&) = default;
>
> _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
> : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
> { }
>
> };
>
> _Rb_tree_impl<_Compare> _M_impl;
>
> protected:
> _Base_ptr&
> _M_root() noexcept
> { return this->_M_impl._M_header._M_parent; }
>
> _Const_Base_ptr
> _M_root() const noexcept
> { return this->_M_impl._M_header._M_parent; }
>
> _Base_ptr&
> _M_leftmost() noexcept
> { return this->_M_impl._M_header._M_left; }
>
> _Const_Base_ptr
> _M_leftmost() const noexcept
> { return this->_M_impl._M_header._M_left; }
>
> _Base_ptr&
> _M_rightmost() noexcept
> { return this->_M_impl._M_header._M_right; }
>
> _Const_Base_ptr
> _M_rightmost() const noexcept
> { return this->_M_impl._M_header._M_right; }
>
> _Link_type
> _M_begin() noexcept
> { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
>
> _Const_Link_type
> _M_begin() const noexcept
> {
> return static_cast<_Const_Link_type>
> (this->_M_impl._M_header._M_parent);
> }
>
> _Base_ptr
> _M_end() noexcept
> { return &this->_M_impl._M_header; }
>
> _Const_Base_ptr
> _M_end() const noexcept
> { return &this->_M_impl._M_header; }
>
> static const_reference
> _S_value(_Const_Link_type __x)
> { return *__x->_M_valptr(); }
>
> static const _Key&
> _S_key(_Const_Link_type __x)
> { return _KeyOfValue()(_S_value(__x)); }
>
> static _Link_type
> _S_left(_Base_ptr __x) noexcept
> { return static_cast<_Link_type>(__x->_M_left); }
>
> static _Const_Link_type
> _S_left(_Const_Base_ptr __x) noexcept
> { return static_cast<_Const_Link_type>(__x->_M_left); }
>
> static _Link_type
> _S_right(_Base_ptr __x) noexcept
> { return static_cast<_Link_type>(__x->_M_right); }
>
> static _Const_Link_type
> _S_right(_Const_Base_ptr __x) noexcept
> { return static_cast<_Const_Link_type>(__x->_M_right); }
>
> static const_reference
> _S_value(_Const_Base_ptr __x)
> { return *static_cast<_Const_Link_type>(__x)->_M_valptr(); }
>
> static const _Key&
> _S_key(_Const_Base_ptr __x)
> { return _KeyOfValue()(_S_value(__x)); }
>
> static _Base_ptr
> _S_minimum(_Base_ptr __x) noexcept
> { return _Rb_tree_node_base::_S_minimum(__x); }
>
> static _Const_Base_ptr
> _S_minimum(_Const_Base_ptr __x) noexcept
> { return _Rb_tree_node_base::_S_minimum(__x); }
>
> static _Base_ptr
> _S_maximum(_Base_ptr __x) noexcept
> { return _Rb_tree_node_base::_S_maximum(__x); }
>
> static _Const_Base_ptr
> _S_maximum(_Const_Base_ptr __x) noexcept
> { return _Rb_tree_node_base::_S_maximum(__x); }
>
> public:
> typedef _Rb_tree_iterator<value_type> iterator;
> typedef _Rb_tree_const_iterator<value_type> const_iterator;
>
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
>
>
> using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
> using insert_return_type = _Node_insert_return<
> conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
> node_type>;
>
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_unique_pos(const key_type& __k);
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_equal_pos(const key_type& __k);
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_hint_unique_pos(const_iterator __pos,
> const key_type& __k);
>
> pair<_Base_ptr, _Base_ptr>
> _M_get_insert_hint_equal_pos(const_iterator __pos,
> const key_type& __k);
>
> private:
>
> template<typename _Arg, typename _NodeGen>
> iterator
> _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
>
> iterator
> _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);
>
> template<typename _Arg>
> iterator
> _M_insert_lower(_Base_ptr __y, _Arg&& __v);
>
> template<typename _Arg>
> iterator
> _M_insert_equal_lower(_Arg&& __x);
>
> iterator
> _M_insert_lower_node(_Base_ptr __p, _Link_type __z);
>
> iterator
> _M_insert_equal_lower_node(_Link_type __z);
># 883 "/usr/include/c++/8/bits/stl_tree.h" 3
> template<typename _NodeGen>
> _Link_type
> _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen&);
>
> template<typename _NodeGen>
> _Link_type
> _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
> {
> _Link_type __root = _M_copy(__x._M_begin(), _M_end(), __gen);
> _M_leftmost() = _S_minimum(__root);
> _M_rightmost() = _S_maximum(__root);
> _M_impl._M_node_count = __x._M_impl._M_node_count;
> return __root;
> }
>
> _Link_type
> _M_copy(const _Rb_tree& __x)
> {
> _Alloc_node __an(*this);
> return _M_copy(__x, __an);
> }
>
> void
> _M_erase(_Link_type __x);
>
> iterator
> _M_lower_bound(_Link_type __x, _Base_ptr __y,
> const _Key& __k);
>
> const_iterator
> _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
> const _Key& __k) const;
>
> iterator
> _M_upper_bound(_Link_type __x, _Base_ptr __y,
> const _Key& __k);
>
> const_iterator
> _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
> const _Key& __k) const;
>
> public:
>
>
>
>
> _Rb_tree() = default;
>
>
> _Rb_tree(const _Compare& __comp,
> const allocator_type& __a = allocator_type())
> : _M_impl(__comp, _Node_allocator(__a)) { }
>
> _Rb_tree(const _Rb_tree& __x)
> : _M_impl(__x._M_impl)
> {
> if (__x._M_root() != 0)
> _M_root() = _M_copy(__x);
> }
>
>
> _Rb_tree(const allocator_type& __a)
> : _M_impl(_Compare(), _Node_allocator(__a))
> { }
>
> _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
> : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
> {
> if (__x._M_root() != nullptr)
> _M_root() = _M_copy(__x);
> }
>
> _Rb_tree(_Rb_tree&&) = default;
>
> _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
> : _Rb_tree(std::move(__x), _Node_allocator(__a))
> { }
>
> _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a);
>
>
> ~_Rb_tree() noexcept
> { _M_erase(_M_begin()); }
>
> _Rb_tree&
> operator=(const _Rb_tree& __x);
>
>
> _Compare
> key_comp() const
> { return _M_impl._M_key_compare; }
>
> iterator
> begin() noexcept
> { return iterator(this->_M_impl._M_header._M_left); }
>
> const_iterator
> begin() const noexcept
> { return const_iterator(this->_M_impl._M_header._M_left); }
>
> iterator
> end() noexcept
> { return iterator(&this->_M_impl._M_header); }
>
> const_iterator
> end() const noexcept
> { return const_iterator(&this->_M_impl._M_header); }
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
> bool
> empty() const noexcept
> { return _M_impl._M_node_count == 0; }
>
> size_type
> size() const noexcept
> { return _M_impl._M_node_count; }
>
> size_type
> max_size() const noexcept
> { return _Alloc_traits::max_size(_M_get_Node_allocator()); }
>
> void
> swap(_Rb_tree& __t)
> noexcept(__is_nothrow_swappable<_Compare>::value);
>
>
>
> template<typename _Arg>
> pair<iterator, bool>
> _M_insert_unique(_Arg&& __x);
>
> template<typename _Arg>
> iterator
> _M_insert_equal(_Arg&& __x);
>
> template<typename _Arg, typename _NodeGen>
> iterator
> _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);
>
> template<typename _Arg>
> iterator
> _M_insert_unique_(const_iterator __pos, _Arg&& __x)
> {
> _Alloc_node __an(*this);
> return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
> }
>
> template<typename _Arg, typename _NodeGen>
> iterator
> _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);
>
> template<typename _Arg>
> iterator
> _M_insert_equal_(const_iterator __pos, _Arg&& __x)
> {
> _Alloc_node __an(*this);
> return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
> }
>
> template<typename... _Args>
> pair<iterator, bool>
> _M_emplace_unique(_Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace_equal(_Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
>
> template<typename... _Args>
> iterator
> _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
># 1103 "/usr/include/c++/8/bits/stl_tree.h" 3
> template<typename _InputIterator>
> void
> _M_insert_unique(_InputIterator __first, _InputIterator __last);
>
> template<typename _InputIterator>
> void
> _M_insert_equal(_InputIterator __first, _InputIterator __last);
>
> private:
> void
> _M_erase_aux(const_iterator __position);
>
> void
> _M_erase_aux(const_iterator __first, const_iterator __last);
>
> public:
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __position)
> {
> ;
> const_iterator __result = __position;
> ++__result;
> _M_erase_aux(__position);
> return __result._M_const_cast();
> }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(iterator __position)
> {
> ;
> iterator __result = __position;
> ++__result;
> _M_erase_aux(__position);
> return __result;
> }
># 1159 "/usr/include/c++/8/bits/stl_tree.h" 3
> size_type
> erase(const key_type& __x);
>
>
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(const_iterator __first, const_iterator __last)
> {
> _M_erase_aux(__first, __last);
> return __last._M_const_cast();
> }
># 1181 "/usr/include/c++/8/bits/stl_tree.h" 3
> void
> erase(const key_type* __first, const key_type* __last);
>
> void
> clear() noexcept
> {
> _M_erase(_M_begin());
> _M_impl._M_reset();
> }
>
>
> iterator
> find(const key_type& __k);
>
> const_iterator
> find(const key_type& __k) const;
>
> size_type
> count(const key_type& __k) const;
>
> iterator
> lower_bound(const key_type& __k)
> { return _M_lower_bound(_M_begin(), _M_end(), __k); }
>
> const_iterator
> lower_bound(const key_type& __k) const
> { return _M_lower_bound(_M_begin(), _M_end(), __k); }
>
> iterator
> upper_bound(const key_type& __k)
> { return _M_upper_bound(_M_begin(), _M_end(), __k); }
>
> const_iterator
> upper_bound(const key_type& __k) const
> { return _M_upper_bound(_M_begin(), _M_end(), __k); }
>
> pair<iterator, iterator>
> equal_range(const key_type& __k);
>
> pair<const_iterator, const_iterator>
> equal_range(const key_type& __k) const;
>
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> iterator
> _M_find_tr(const _Kt& __k)
> {
> const _Rb_tree* __const_this = this;
> return __const_this->_M_find_tr(__k)._M_const_cast();
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> const_iterator
> _M_find_tr(const _Kt& __k) const
> {
> auto __j = _M_lower_bound_tr(__k);
> if (__j != end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node)))
> __j = end();
> return __j;
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> 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 =
> typename __has_is_transparent<_Compare, _Kt>::type>
> iterator
> _M_lower_bound_tr(const _Kt& __k)
> {
> const _Rb_tree* __const_this = this;
> return __const_this->_M_lower_bound_tr(__k)._M_const_cast();
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> const_iterator
> _M_lower_bound_tr(const _Kt& __k) const
> {
> auto __x = _M_begin();
> auto __y = _M_end();
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> {
> __y = __x;
> __x = _S_left(__x);
> }
> else
> __x = _S_right(__x);
> return const_iterator(__y);
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> iterator
> _M_upper_bound_tr(const _Kt& __k)
> {
> const _Rb_tree* __const_this = this;
> return __const_this->_M_upper_bound_tr(__k)._M_const_cast();
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> const_iterator
> _M_upper_bound_tr(const _Kt& __k) const
> {
> auto __x = _M_begin();
> auto __y = _M_end();
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> {
> __y = __x;
> __x = _S_left(__x);
> }
> else
> __x = _S_right(__x);
> return const_iterator(__y);
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> pair<iterator, iterator>
> _M_equal_range_tr(const _Kt& __k)
> {
> const _Rb_tree* __const_this = this;
> auto __ret = __const_this->_M_equal_range_tr(__k);
> return { __ret.first._M_const_cast(), __ret.second._M_const_cast() };
> }
>
> template<typename _Kt,
> typename _Req =
> typename __has_is_transparent<_Compare, _Kt>::type>
> pair<const_iterator, const_iterator>
> _M_equal_range_tr(const _Kt& __k) const
> {
> auto __low = _M_lower_bound_tr(__k);
> auto __high = __low;
> auto& __cmp = _M_impl._M_key_compare;
> while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
> ++__high;
> return { __low, __high };
> }
>
>
>
> bool
> __rb_verify() const;
>
>
> _Rb_tree&
> operator=(_Rb_tree&&)
> noexcept(_Alloc_traits::_S_nothrow_move()
> && is_nothrow_move_assignable<_Compare>::value);
>
> template<typename _Iterator>
> void
> _M_assign_unique(_Iterator, _Iterator);
>
> template<typename _Iterator>
> void
> _M_assign_equal(_Iterator, _Iterator);
>
> private:
>
> void
> _M_move_data(_Rb_tree& __x, std::true_type)
> { _M_impl._M_move_data(__x._M_impl); }
>
>
>
> void
> _M_move_data(_Rb_tree&, std::false_type);
>
>
> void
> _M_move_assign(_Rb_tree&, std::true_type);
>
>
>
> void
> _M_move_assign(_Rb_tree&, std::false_type);
>
>
>
> public:
>
> insert_return_type
> _M_reinsert_node_unique(node_type&& __nh)
> {
> insert_return_type __ret;
> if (__nh.empty())
> __ret.position = end();
> else
> {
> ;
>
> auto __res = _M_get_insert_unique_pos(__nh._M_key());
> if (__res.second)
> {
> __ret.position
> = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
> __nh._M_ptr = nullptr;
> __ret.inserted = true;
> }
> else
> {
> __ret.node = std::move(__nh);
> __ret.position = iterator(__res.first);
> __ret.inserted = false;
> }
> }
> return __ret;
> }
>
>
> iterator
> _M_reinsert_node_equal(node_type&& __nh)
> {
> iterator __ret;
> if (__nh.empty())
> __ret = end();
> else
> {
> ;
> auto __res = _M_get_insert_equal_pos(__nh._M_key());
> if (__res.second)
> __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
> else
> __ret = _M_insert_equal_lower_node(__nh._M_ptr);
> __nh._M_ptr = nullptr;
> }
> return __ret;
> }
>
>
> iterator
> _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
> {
> iterator __ret;
> if (__nh.empty())
> __ret = end();
> else
> {
> ;
> auto __res = _M_get_insert_hint_unique_pos(__hint, __nh._M_key());
> if (__res.second)
> {
> __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
> __nh._M_ptr = nullptr;
> }
> else
> __ret = iterator(__res.first);
> }
> return __ret;
> }
>
>
> iterator
> _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh)
> {
> iterator __ret;
> if (__nh.empty())
> __ret = end();
> else
> {
> ;
> auto __res = _M_get_insert_hint_equal_pos(__hint, __nh._M_key());
> if (__res.second)
> __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
> else
> __ret = _M_insert_equal_lower_node(__nh._M_ptr);
> __nh._M_ptr = nullptr;
> }
> return __ret;
> }
>
>
> node_type
> extract(const_iterator __pos)
> {
> auto __ptr = _Rb_tree_rebalance_for_erase(
> __pos._M_const_cast()._M_node, _M_impl._M_header);
> --_M_impl._M_node_count;
> return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() };
> }
>
>
> node_type
> extract(const key_type& __k)
> {
> node_type __nh;
> auto __pos = find(__k);
> if (__pos != end())
> __nh = extract(const_iterator(__pos));
> return __nh;
> }
>
> template<typename _Compare2>
> using _Compatible_tree
> = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;
>
> template<typename, typename>
> friend class _Rb_tree_merge_helper;
>
>
> template<typename _Compare2>
> void
> _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
> {
> using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
> for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
> {
> auto __pos = __i++;
> auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
> if (__res.second)
> {
> auto& __src_impl = _Merge_helper::_S_get_impl(__src);
> auto __ptr = _Rb_tree_rebalance_for_erase(
> __pos._M_node, __src_impl._M_header);
> --__src_impl._M_node_count;
> _M_insert_node(__res.first, __res.second,
> static_cast<_Link_type>(__ptr));
> }
> }
> }
>
>
> template<typename _Compare2>
> void
> _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept
> {
> using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
> for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
> {
> auto __pos = __i++;
> auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos));
> if (__res.second)
> {
> auto& __src_impl = _Merge_helper::_S_get_impl(__src);
> auto __ptr = _Rb_tree_rebalance_for_erase(
> __pos._M_node, __src_impl._M_header);
> --__src_impl._M_node_count;
> _M_insert_node(__res.first, __res.second,
> static_cast<_Link_type>(__ptr));
> }
> }
> }
>
> };
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> {
> return __x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> {
> return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline bool
> operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
> { __x.swap(__y); }
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
> : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
> {
> using __eq = typename _Alloc_traits::is_always_equal;
> if (__x._M_root() != nullptr)
> _M_move_data(__x, __eq());
> }
>
> 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, std::false_type)
> {
> if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
> _M_move_data(__x, std::true_type());
> else
> {
> _Alloc_node __an(*this);
> auto __lbd =
> [&__an](const value_type& __cval)
> {
> auto& __val = const_cast<value_type&>(__cval);
> return __an(std::move_if_noexcept(__val));
> };
> _M_root() = _M_copy(__x, __lbd);
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_move_assign(_Rb_tree& __x, true_type)
> {
> clear();
> if (__x._M_root() != nullptr)
> _M_move_data(__x, std::true_type());
> std::__alloc_on_move(_M_get_Node_allocator(),
> __x._M_get_Node_allocator());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_move_assign(_Rb_tree& __x, false_type)
> {
> if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
> return _M_move_assign(__x, true_type{});
>
>
>
> _Reuse_or_alloc_node __roan(*this);
> _M_impl._M_reset();
> if (__x._M_root() != nullptr)
> {
> auto __lbd =
> [&__roan](const value_type& __cval)
> {
> auto& __val = const_cast<value_type&>(__cval);
> return __roan(std::move_if_noexcept(__val));
> };
> _M_root() = _M_copy(__x, __lbd);
> __x.clear();
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> operator=(_Rb_tree&& __x)
> noexcept(_Alloc_traits::_S_nothrow_move()
> && is_nothrow_move_assignable<_Compare>::value)
> {
> _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
> _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>());
> return *this;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename _Iterator>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_assign_unique(_Iterator __first, _Iterator __last)
> {
> _Reuse_or_alloc_node __roan(*this);
> _M_impl._M_reset();
> for (; __first != __last; ++__first)
> _M_insert_unique_(end(), *__first, __roan);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename _Iterator>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_assign_equal(_Iterator __first, _Iterator __last)
> {
> _Reuse_or_alloc_node __roan(*this);
> _M_impl._M_reset();
> for (; __first != __last; ++__first)
> _M_insert_equal_(end(), *__first, __roan);
> }
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> operator=(const _Rb_tree& __x)
> {
> if (this != &__x)
> {
>
>
> if (_Alloc_traits::_S_propagate_on_copy_assign())
> {
> auto& __this_alloc = this->_M_get_Node_allocator();
> auto& __that_alloc = __x._M_get_Node_allocator();
> if (!_Alloc_traits::_S_always_equal()
> && __this_alloc != __that_alloc)
> {
>
>
> clear();
> std::__alloc_on_copy(__this_alloc, __that_alloc);
> }
> }
>
>
> _Reuse_or_alloc_node __roan(*this);
> _M_impl._M_reset();
> _M_impl._M_key_compare = __x._M_impl._M_key_compare;
> if (__x._M_root() != 0)
> _M_root() = _M_copy(__x, __roan);
> }
>
> return *this;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg, typename _NodeGen>
>
>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_(_Base_ptr __x, _Base_ptr __p,
>
> _Arg&& __v,
>
>
>
> _NodeGen& __node_gen)
> {
> bool __insert_left = (__x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_KeyOfValue()(__v),
> _S_key(__p)));
>
> _Link_type __z = __node_gen(std::forward<_Arg>(__v));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_lower(_Base_ptr __p, _Arg&& __v)
>
>
>
> {
> bool __insert_left = (__p == _M_end()
> || !_M_impl._M_key_compare(_S_key(__p),
> _KeyOfValue()(__v)));
>
> _Link_type __z = _M_create_node(std::forward<_Arg>(__v));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_equal_lower(_Arg&& __v)
>
>
>
> {
> _Link_type __x = _M_begin();
> _Base_ptr __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _M_insert_lower(__y, std::forward<_Arg>(__v));
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Compare, typename _Alloc>
> template<typename _NodeGen>
> typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
> _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
> _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen)
> {
>
> _Link_type __top = _M_clone_node(__x, __node_gen);
> __top->_M_parent = __p;
>
> try
> {
> if (__x->_M_right)
> __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen);
> __p = __top;
> __x = _S_left(__x);
>
> while (__x != 0)
> {
> _Link_type __y = _M_clone_node(__x, __node_gen);
> __p->_M_left = __y;
> __y->_M_parent = __p;
> if (__x->_M_right)
> __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen);
> __p = __y;
> __x = _S_left(__x);
> }
> }
> catch(...)
> {
> _M_erase(__top);
> throw;
> }
> return __top;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase(_Link_type __x)
> {
>
> while (__x != 0)
> {
> _M_erase(_S_right(__x));
> _Link_type __y = _S_left(__x);
> _M_drop_node(__x);
> __x = __y;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_lower_bound(_Link_type __x, _Base_ptr __y,
> const _Key& __k)
> {
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
> const _Key& __k) const
> {
> while (__x != 0)
> if (!_M_impl._M_key_compare(_S_key(__x), __k))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return const_iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_upper_bound(_Link_type __x, _Base_ptr __y,
> const _Key& __k)
> {
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
> const _Key& __k) const
> {
> while (__x != 0)
> if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> __x = _S_right(__x);
> return const_iterator(__y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> equal_range(const _Key& __k)
> {
> _Link_type __x = _M_begin();
> _Base_ptr __y = _M_end();
> while (__x != 0)
> {
> if (_M_impl._M_key_compare(_S_key(__x), __k))
> __x = _S_right(__x);
> else if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> {
> _Link_type __xu(__x);
> _Base_ptr __yu(__y);
> __y = __x, __x = _S_left(__x);
> __xu = _S_right(__xu);
> return pair<iterator,
> iterator>(_M_lower_bound(__x, __y, __k),
> _M_upper_bound(__xu, __yu, __k));
> }
> }
> return pair<iterator, iterator>(iterator(__y),
> iterator(__y));
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> equal_range(const _Key& __k) const
> {
> _Const_Link_type __x = _M_begin();
> _Const_Base_ptr __y = _M_end();
> while (__x != 0)
> {
> if (_M_impl._M_key_compare(_S_key(__x), __k))
> __x = _S_right(__x);
> else if (_M_impl._M_key_compare(__k, _S_key(__x)))
> __y = __x, __x = _S_left(__x);
> else
> {
> _Const_Link_type __xu(__x);
> _Const_Base_ptr __yu(__y);
> __y = __x, __x = _S_left(__x);
> __xu = _S_right(__xu);
> return pair<const_iterator,
> const_iterator>(_M_lower_bound(__x, __y, __k),
> _M_upper_bound(__xu, __yu, __k));
> }
> }
> return pair<const_iterator, const_iterator>(const_iterator(__y),
> const_iterator(__y));
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> swap(_Rb_tree& __t)
> noexcept(__is_nothrow_swappable<_Compare>::value)
> {
> if (_M_root() == 0)
> {
> if (__t._M_root() != 0)
> _M_impl._M_move_data(__t._M_impl);
> }
> else if (__t._M_root() == 0)
> __t._M_impl._M_move_data(_M_impl);
> else
> {
> std::swap(_M_root(),__t._M_root());
> std::swap(_M_leftmost(),__t._M_leftmost());
> std::swap(_M_rightmost(),__t._M_rightmost());
>
> _M_root()->_M_parent = _M_end();
> __t._M_root()->_M_parent = __t._M_end();
> std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
> }
>
> std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
>
> _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
> __t._M_get_Node_allocator());
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_unique_pos(const key_type& __k)
> {
> typedef pair<_Base_ptr, _Base_ptr> _Res;
> _Link_type __x = _M_begin();
> _Base_ptr __y = _M_end();
> bool __comp = true;
> while (__x != 0)
> {
> __y = __x;
> __comp = _M_impl._M_key_compare(__k, _S_key(__x));
> __x = __comp ? _S_left(__x) : _S_right(__x);
> }
> iterator __j = iterator(__y);
> if (__comp)
> {
> if (__j == begin())
> return _Res(__x, __y);
> else
> --__j;
> }
> if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
> return _Res(__x, __y);
> return _Res(__j._M_node, 0);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_equal_pos(const key_type& __k)
> {
> typedef pair<_Base_ptr, _Base_ptr> _Res;
> _Link_type __x = _M_begin();
> _Base_ptr __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _Res(__x, __y);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator, bool>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_unique(_Arg&& __v)
>
>
>
> {
> typedef pair<iterator, bool> _Res;
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_unique_pos(_KeyOfValue()(__v));
>
> if (__res.second)
> {
> _Alloc_node __an(*this);
> return _Res(_M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v), __an),
> true);
> }
>
> return _Res(iterator(__res.first), false);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
>
> _M_insert_equal(_Arg&& __v)
>
>
>
> {
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_equal_pos(_KeyOfValue()(__v));
> _Alloc_node __an(*this);
> return _M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v), __an);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_hint_unique_pos(const_iterator __position,
> const key_type& __k)
> {
> iterator __pos = __position._M_const_cast();
> typedef pair<_Base_ptr, _Base_ptr> _Res;
>
>
> if (__pos._M_node == _M_end())
> {
> if (size() > 0
> && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
> return _Res(0, _M_rightmost());
> else
> return _M_get_insert_unique_pos(__k);
> }
> else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
> {
>
> iterator __before = __pos;
> if (__pos._M_node == _M_leftmost())
> return _Res(_M_leftmost(), _M_leftmost());
> else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
> {
> if (_S_right(__before._M_node) == 0)
> return _Res(0, __before._M_node);
> else
> return _Res(__pos._M_node, __pos._M_node);
> }
> else
> return _M_get_insert_unique_pos(__k);
> }
> else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
> {
>
> iterator __after = __pos;
> if (__pos._M_node == _M_rightmost())
> return _Res(0, _M_rightmost());
> else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
> {
> if (_S_right(__pos._M_node) == 0)
> return _Res(0, __pos._M_node);
> else
> return _Res(__after._M_node, __after._M_node);
> }
> else
> return _M_get_insert_unique_pos(__k);
> }
> else
>
> return _Res(__pos._M_node, 0);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg, typename _NodeGen>
>
>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_unique_(const_iterator __position,
>
> _Arg&& __v,
>
>
>
> _NodeGen& __node_gen)
> {
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
>
> if (__res.second)
> return _M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v),
> __node_gen);
> return iterator(__res.first);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr,
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::_Base_ptr>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
> {
> iterator __pos = __position._M_const_cast();
> typedef pair<_Base_ptr, _Base_ptr> _Res;
>
>
> if (__pos._M_node == _M_end())
> {
> if (size() > 0
> && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
> return _Res(0, _M_rightmost());
> else
> return _M_get_insert_equal_pos(__k);
> }
> else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
> {
>
> iterator __before = __pos;
> if (__pos._M_node == _M_leftmost())
> return _Res(_M_leftmost(), _M_leftmost());
> else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
> {
> if (_S_right(__before._M_node) == 0)
> return _Res(0, __before._M_node);
> else
> return _Res(__pos._M_node, __pos._M_node);
> }
> else
> return _M_get_insert_equal_pos(__k);
> }
> else
> {
>
> iterator __after = __pos;
> if (__pos._M_node == _M_rightmost())
> return _Res(0, _M_rightmost());
> else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
> {
> if (_S_right(__pos._M_node) == 0)
> return _Res(0, __pos._M_node);
> else
> return _Res(__after._M_node, __after._M_node);
> }
> else
> return _Res(0, 0);
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
>
> template<typename _Arg, typename _NodeGen>
>
>
>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_equal_(const_iterator __position,
>
> _Arg&& __v,
>
>
>
> _NodeGen& __node_gen)
> {
> pair<_Base_ptr, _Base_ptr> __res
> = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
>
> if (__res.second)
> return _M_insert_(__res.first, __res.second,
> std::forward<_Arg>(__v),
> __node_gen);
>
> return _M_insert_equal_lower(std::forward<_Arg>(__v));
> }
>
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
> {
> bool __insert_left = (__x != 0 || __p == _M_end()
> || _M_impl._M_key_compare(_S_key(__z),
> _S_key(__p)));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
> {
> bool __insert_left = (__p == _M_end()
> || !_M_impl._M_key_compare(_S_key(__p),
> _S_key(__z)));
>
> _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
> this->_M_impl._M_header);
> ++_M_impl._M_node_count;
> return iterator(__z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_insert_equal_lower_node(_Link_type __z)
> {
> _Link_type __x = _M_begin();
> _Base_ptr __y = _M_end();
> while (__x != 0)
> {
> __y = __x;
> __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
> _S_left(__x) : _S_right(__x);
> }
> return _M_insert_lower_node(__y, __z);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator, bool>
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_unique(_Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> typedef pair<iterator, bool> _Res;
> auto __res = _M_get_insert_unique_pos(_S_key(__z));
> if (__res.second)
> return _Res(_M_insert_node(__res.first, __res.second, __z), true);
>
> _M_drop_node(__z);
> return _Res(iterator(__res.first), false);
> }
> catch(...)
> {
> _M_drop_node(__z);
> throw;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_equal(_Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> auto __res = _M_get_insert_equal_pos(_S_key(__z));
> return _M_insert_node(__res.first, __res.second, __z);
> }
> catch(...)
> {
> _M_drop_node(__z);
> throw;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));
>
> if (__res.second)
> return _M_insert_node(__res.first, __res.second, __z);
>
> _M_drop_node(__z);
> return iterator(__res.first);
> }
> catch(...)
> {
> _M_drop_node(__z);
> throw;
> }
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> template<typename... _Args>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
> {
> _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
>
> try
> {
> auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));
>
> if (__res.second)
> return _M_insert_node(__res.first, __res.second, __z);
>
> return _M_insert_equal_lower_node(__z);
> }
> catch(...)
> {
> _M_drop_node(__z);
> throw;
> }
> }
>
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
> _M_insert_unique(_II __first, _II __last)
> {
> _Alloc_node __an(*this);
> for (; __first != __last; ++__first)
> _M_insert_unique_(end(), *__first, __an);
> }
>
> template<typename _Key, typename _Val, typename _KoV,
> typename _Cmp, typename _Alloc>
> template<class _II>
> void
> _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
> _M_insert_equal(_II __first, _II __last)
> {
> _Alloc_node __an(*this);
> for (; __first != __last; ++__first)
> _M_insert_equal_(end(), *__first, __an);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase_aux(const_iterator __position)
> {
> _Link_type __y =
> static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
> (const_cast<_Base_ptr>(__position._M_node),
> this->_M_impl._M_header));
> _M_drop_node(__y);
> --_M_impl._M_node_count;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> _M_erase_aux(const_iterator __first, const_iterator __last)
> {
> if (__first == begin() && __last == end())
> clear();
> else
> while (__first != __last)
> _M_erase_aux(__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const _Key& __x)
> {
> pair<iterator, iterator> __p = equal_range(__x);
> const size_type __old_size = size();
> _M_erase_aux(__p.first, __p.second);
> return __old_size - size();
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> void
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> erase(const _Key* __first, const _Key* __last)
> {
> while (__first != __last)
> erase(*__first++);
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> find(const _Key& __k)
> {
> iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
> return (__j == end()
> || _M_impl._M_key_compare(__k,
> _S_key(__j._M_node))) ? end() : __j;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue,
> _Compare, _Alloc>::const_iterator
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> find(const _Key& __k) const
> {
> const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
> return (__j == end()
> || _M_impl._M_key_compare(__k,
> _S_key(__j._M_node))) ? end() : __j;
> }
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
> count(const _Key& __k) const
> {
> pair<const_iterator, const_iterator> __p = equal_range(__k);
> const size_type __n = std::distance(__p.first, __p.second);
> return __n;
> }
>
> __attribute__ ((__pure__)) unsigned int
> _Rb_tree_black_count(const _Rb_tree_node_base* __node,
> const _Rb_tree_node_base* __root) throw ();
>
> template<typename _Key, typename _Val, typename _KeyOfValue,
> typename _Compare, typename _Alloc>
> bool
> _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
> {
> if (_M_impl._M_node_count == 0 || begin() == end())
> return _M_impl._M_node_count == 0 && begin() == end()
> && this->_M_impl._M_header._M_left == _M_end()
> && this->_M_impl._M_header._M_right == _M_end();
>
> unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
> for (const_iterator __it = begin(); __it != end(); ++__it)
> {
> _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
> _Const_Link_type __L = _S_left(__x);
> _Const_Link_type __R = _S_right(__x);
>
> if (__x->_M_color == _S_red)
> if ((__L && __L->_M_color == _S_red)
> || (__R && __R->_M_color == _S_red))
> return false;
>
> if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
> return false;
> if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
> return false;
>
> if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
> return false;
> }
>
> if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
> return false;
> if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
> return false;
> return true;
> }
>
>
>
> template<typename _Key, typename _Val, typename _Sel, typename _Cmp1,
> typename _Alloc, typename _Cmp2>
> struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>,
> _Cmp2>
> {
> private:
> friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>;
>
> static auto&
> _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree)
> { return __tree._M_impl; }
> };
>
>
>
>}
># 61 "/usr/include/c++/8/map" 2 3
># 1 "/usr/include/c++/8/bits/stl_map.h" 1 3
># 66 "/usr/include/c++/8/bits/stl_map.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> class multimap;
># 98 "/usr/include/c++/8/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:
># 122 "/usr/include/c++/8/bits/stl_map.h" 3
> static_assert(is_same<typename _Alloc::value_type, value_type>::value,
> "std::map must have the same value_type as its allocator");
>
>
> public:
> class value_compare
> : public std::binary_function<value_type, value_type, bool>
> {
> friend class map<_Key, _Tp, _Compare, _Alloc>;
> protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
> public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
> };
>
> private:
>
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<value_type>::other _Pair_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
> key_compare, _Pair_alloc_type> _Rep_type;
>
>
> _Rep_type _M_t;
>
> typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;
>
> public:
>
>
> typedef typename _Alloc_traits::pointer pointer;
> typedef typename _Alloc_traits::const_pointer const_pointer;
> typedef typename _Alloc_traits::reference reference;
> typedef typename _Alloc_traits::const_reference const_reference;
> typedef typename _Rep_type::iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
> typedef typename _Rep_type::reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
> using node_type = typename _Rep_type::node_type;
> using insert_return_type = typename _Rep_type::insert_return_type;
># 183 "/usr/include/c++/8/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)) { }
># 205 "/usr/include/c++/8/bits/stl_map.h" 3
> map(const map&) = default;
>
>
>
>
>
>
>
> map(map&&) = default;
># 226 "/usr/include/c++/8/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_unique(__l.begin(), __l.end()); }
>
>
> explicit
> map(const allocator_type& __a)
> : _M_t(_Compare(), _Pair_alloc_type(__a)) { }
>
>
> map(const map& __m, const allocator_type& __a)
> : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
>
>
> map(map&& __m, const allocator_type& __a)
> noexcept(is_nothrow_copy_constructible<_Compare>::value
> && _Alloc_traits::_S_always_equal())
> : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
>
>
> map(initializer_list<value_type> __l, const allocator_type& __a)
> : _M_t(_Compare(), _Pair_alloc_type(__a))
> { _M_t._M_insert_unique(__l.begin(), __l.end()); }
>
>
> template<typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a)
> : _M_t(_Compare(), _Pair_alloc_type(__a))
> { _M_t._M_insert_unique(__first, __last); }
># 270 "/usr/include/c++/8/bits/stl_map.h" 3
> template<typename _InputIterator>
> map(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_unique(__first, __last); }
># 287 "/usr/include/c++/8/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_unique(__first, __last); }
>
>
>
>
>
>
>
> ~map() = default;
># 316 "/usr/include/c++/8/bits/stl_map.h" 3
> map&
> operator=(const map&) = default;
>
>
> map&
> operator=(map&&) = default;
># 334 "/usr/include/c++/8/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(); }
>
>
>
>
>
>
> bool
> empty() const noexcept
> { return _M_t.empty(); }
>
>
> size_type
> size() const noexcept
> { return _M_t.size(); }
>
>
> size_type
> max_size() const noexcept
> { return _M_t.max_size(); }
># 489 "/usr/include/c++/8/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;
> }
># 534 "/usr/include/c++/8/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;
> }
># 572 "/usr/include/c++/8/bits/stl_map.h" 3
> template<typename... _Args>
> std::pair<iterator, bool>
> emplace(_Args&&... __args)
> { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
># 602 "/usr/include/c++/8/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)
> {
> ;
> return _M_t.extract(__pos);
> }
>
>
> node_type
> extract(const key_type& __x)
> { return _M_t.extract(__x); }
>
>
> insert_return_type
> insert(node_type&& __nh)
> { return _M_t._M_reinsert_node_unique(std::move(__nh)); }
>
>
> iterator
> insert(const_iterator __hint, node_type&& __nh)
> { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }
>
> template<typename, typename>
> friend class std::_Rb_tree_merge_helper;
>
> template<typename _C2>
> void
> merge(map<_Key, _Tp, _C2, _Alloc>& __source)
> {
> using _Merge_helper = _Rb_tree_merge_helper<map, _C2>;
> _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
> }
>
> template<typename _C2>
> void
> merge(map<_Key, _Tp, _C2, _Alloc>&& __source)
> { merge(__source); }
>
> template<typename _C2>
> void
> merge(multimap<_Key, _Tp, _C2, _Alloc>& __source)
> {
> using _Merge_helper = _Rb_tree_merge_helper<map, _C2>;
> _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
> }
>
> template<typename _C2>
> void
> merge(multimap<_Key, _Tp, _C2, _Alloc>&& __source)
> { merge(__source); }
># 687 "/usr/include/c++/8/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};
> }
># 747 "/usr/include/c++/8/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;
> }
># 800 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> std::pair<iterator, bool>
> insert(_Pair&& __x)
> { return _M_t._M_insert_unique(std::forward<_Pair>(__x)); }
># 828 "/usr/include/c++/8/bits/stl_map.h" 3
> void
> insert(std::initializer_list<value_type> __list)
> { insert(__list.begin(), __list.end()); }
># 857 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(const_iterator __position, _Pair&& __x)
> { return _M_t._M_insert_unique_(__position,
> std::forward<_Pair>(__x)); }
># 890 "/usr/include/c++/8/bits/stl_map.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_unique(__first, __last); }
># 916 "/usr/include/c++/8/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};
> }
># 971 "/usr/include/c++/8/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;
> }
># 1030 "/usr/include/c++/8/bits/stl_map.h" 3
> iterator
> erase(const_iterator __position)
> { return _M_t.erase(__position); }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(iterator __position)
> { return _M_t.erase(__position); }
># 1067 "/usr/include/c++/8/bits/stl_map.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 1087 "/usr/include/c++/8/bits/stl_map.h" 3
> iterator
> erase(const_iterator __first, const_iterator __last)
> { return _M_t.erase(__first, __last); }
># 1121 "/usr/include/c++/8/bits/stl_map.h" 3
> void
> swap(map& __x)
> noexcept(__is_nothrow_swappable<_Compare>::value)
> { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_t.clear(); }
>
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
>
>
>
>
> value_compare
> value_comp() const
> { return value_compare(_M_t.key_comp()); }
># 1168 "/usr/include/c++/8/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); }
># 1193 "/usr/include/c++/8/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); }
># 1214 "/usr/include/c++/8/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); }
># 1238 "/usr/include/c++/8/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)); }
># 1263 "/usr/include/c++/8/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)); }
># 1283 "/usr/include/c++/8/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)); }
># 1303 "/usr/include/c++/8/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)); }
># 1332 "/usr/include/c++/8/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)); }
># 1361 "/usr/include/c++/8/bits/stl_map.h" 3
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
>
> template<typename _Kt>
> auto
> equal_range(const _Kt& __x) const
> -> decltype(pair<const_iterator, const_iterator>(
> _M_t._M_equal_range_tr(__x)))
> {
> return pair<const_iterator, const_iterator>(
> _M_t._M_equal_range_tr(__x));
> }
>
>
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator==(const map<_K1, _T1, _C1, _A1>&,
> const map<_K1, _T1, _C1, _A1>&);
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator<(const map<_K1, _T1, _C1, _A1>&,
> const map<_K1, _T1, _C1, _A1>&);
> };
>
>
>
>
> template<typename _InputIterator,
> typename _Compare = less<__iter_key_t<_InputIterator>>,
> typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
> typename = _RequireInputIter<_InputIterator>,
> typename = _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 = _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>;
># 1433 "/usr/include/c++/8/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; }
># 1450 "/usr/include/c++/8/bits/stl_map.h" 3
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
> const map<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline void
> swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
> map<_Key, _Tp, _Compare, _Alloc>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
>
>
>
> template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
> typename _Cmp2>
> struct
> _Rb_tree_merge_helper<std::map<_Key, _Val, _Cmp1, _Alloc>,
> _Cmp2>
> {
> private:
> friend class std::map<_Key, _Val, _Cmp1, _Alloc>;
>
> static auto&
> _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
> { return __map._M_t; }
>
> static auto&
> _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
> { return __map._M_t; }
> };
>
>
>
>}
># 62 "/usr/include/c++/8/map" 2 3
># 1 "/usr/include/c++/8/bits/stl_multimap.h" 1 3
># 64 "/usr/include/c++/8/bits/stl_multimap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> class map;
># 96 "/usr/include/c++/8/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:
># 121 "/usr/include/c++/8/bits/stl_multimap.h" 3
> static_assert(is_same<typename _Alloc::value_type, value_type>::value,
> "std::multimap must have the same value_type as its allocator");
>
>
> public:
> class value_compare
> : public std::binary_function<value_type, value_type, bool>
> {
> friend class multimap<_Key, _Tp, _Compare, _Alloc>;
> protected:
> _Compare comp;
>
> value_compare(_Compare __c)
> : comp(__c) { }
>
> public:
> bool operator()(const value_type& __x, const value_type& __y) const
> { return comp(__x.first, __y.first); }
> };
>
> private:
>
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<value_type>::other _Pair_alloc_type;
>
> typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
> key_compare, _Pair_alloc_type> _Rep_type;
>
> _Rep_type _M_t;
>
> typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;
>
> public:
>
>
> typedef typename _Alloc_traits::pointer pointer;
> typedef typename _Alloc_traits::const_pointer const_pointer;
> typedef typename _Alloc_traits::reference reference;
> typedef typename _Alloc_traits::const_reference const_reference;
> typedef typename _Rep_type::iterator iterator;
> typedef typename _Rep_type::const_iterator const_iterator;
> typedef typename _Rep_type::size_type size_type;
> typedef typename _Rep_type::difference_type difference_type;
> typedef typename _Rep_type::reverse_iterator reverse_iterator;
> typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
>
>
> using node_type = typename _Rep_type::node_type;
># 180 "/usr/include/c++/8/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)) { }
># 202 "/usr/include/c++/8/bits/stl_multimap.h" 3
> multimap(const multimap&) = default;
># 211 "/usr/include/c++/8/bits/stl_multimap.h" 3
> multimap(multimap&&) = default;
># 223 "/usr/include/c++/8/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_equal(__l.begin(), __l.end()); }
>
>
> explicit
> multimap(const allocator_type& __a)
> : _M_t(_Compare(), _Pair_alloc_type(__a)) { }
>
>
> multimap(const multimap& __m, const allocator_type& __a)
> : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
>
>
> multimap(multimap&& __m, const allocator_type& __a)
> noexcept(is_nothrow_copy_constructible<_Compare>::value
> && _Alloc_traits::_S_always_equal())
> : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
>
>
> multimap(initializer_list<value_type> __l, const allocator_type& __a)
> : _M_t(_Compare(), _Pair_alloc_type(__a))
> { _M_t._M_insert_equal(__l.begin(), __l.end()); }
>
>
> template<typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a)
> : _M_t(_Compare(), _Pair_alloc_type(__a))
> { _M_t._M_insert_equal(__first, __last); }
># 266 "/usr/include/c++/8/bits/stl_multimap.h" 3
> template<typename _InputIterator>
> multimap(_InputIterator __first, _InputIterator __last)
> : _M_t()
> { _M_t._M_insert_equal(__first, __last); }
># 282 "/usr/include/c++/8/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_equal(__first, __last); }
>
>
>
>
>
>
>
> ~multimap() = default;
># 311 "/usr/include/c++/8/bits/stl_multimap.h" 3
> multimap&
> operator=(const multimap&) = default;
>
>
> multimap&
> operator=(multimap&&) = default;
># 329 "/usr/include/c++/8/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(); }
>
>
>
>
> 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(); }
># 487 "/usr/include/c++/8/bits/stl_multimap.h" 3
> template<typename... _Args>
> iterator
> emplace(_Args&&... __args)
> { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
># 514 "/usr/include/c++/8/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)...);
> }
># 536 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(_Pair&& __x)
> { return _M_t._M_insert_equal(std::forward<_Pair>(__x)); }
># 577 "/usr/include/c++/8/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, typename = typename
> std::enable_if<std::is_constructible<value_type,
> _Pair&&>::value>::type>
> iterator
> insert(const_iterator __position, _Pair&& __x)
> { return _M_t._M_insert_equal_(__position,
> std::forward<_Pair>(__x)); }
># 611 "/usr/include/c++/8/bits/stl_multimap.h" 3
> template<typename _InputIterator>
> void
> insert(_InputIterator __first, _InputIterator __last)
> { _M_t._M_insert_equal(__first, __last); }
># 624 "/usr/include/c++/8/bits/stl_multimap.h" 3
> void
> insert(initializer_list<value_type> __l)
> { this->insert(__l.begin(), __l.end()); }
>
>
>
>
> node_type
> extract(const_iterator __pos)
> {
> ;
> return _M_t.extract(__pos);
> }
>
>
> node_type
> extract(const key_type& __x)
> { return _M_t.extract(__x); }
>
>
> iterator
> insert(node_type&& __nh)
> { return _M_t._M_reinsert_node_equal(std::move(__nh)); }
>
>
> iterator
> insert(const_iterator __hint, node_type&& __nh)
> { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }
>
> template<typename, typename>
> friend class std::_Rb_tree_merge_helper;
>
> template<typename _C2>
> void
> merge(multimap<_Key, _Tp, _C2, _Alloc>& __source)
> {
> using _Merge_helper = _Rb_tree_merge_helper<multimap, _C2>;
> _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
> }
>
> template<typename _C2>
> void
> merge(multimap<_Key, _Tp, _C2, _Alloc>&& __source)
> { merge(__source); }
>
> template<typename _C2>
> void
> merge(map<_Key, _Tp, _C2, _Alloc>& __source)
> {
> using _Merge_helper = _Rb_tree_merge_helper<multimap, _C2>;
> _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
> }
>
> template<typename _C2>
> void
> merge(map<_Key, _Tp, _C2, _Alloc>&& __source)
> { merge(__source); }
># 701 "/usr/include/c++/8/bits/stl_multimap.h" 3
> iterator
> erase(const_iterator __position)
> { return _M_t.erase(__position); }
>
>
> __attribute ((__abi_tag__ ("cxx11")))
> iterator
> erase(iterator __position)
> { return _M_t.erase(__position); }
># 738 "/usr/include/c++/8/bits/stl_multimap.h" 3
> size_type
> erase(const key_type& __x)
> { return _M_t.erase(__x); }
># 759 "/usr/include/c++/8/bits/stl_multimap.h" 3
> iterator
> erase(const_iterator __first, const_iterator __last)
> { return _M_t.erase(__first, __last); }
># 796 "/usr/include/c++/8/bits/stl_multimap.h" 3
> void
> swap(multimap& __x)
> noexcept(__is_nothrow_swappable<_Compare>::value)
> { _M_t.swap(__x._M_t); }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_t.clear(); }
>
>
>
>
>
>
> key_compare
> key_comp() const
> { return _M_t.key_comp(); }
>
>
>
>
>
> value_compare
> value_comp() const
> { return value_compare(_M_t.key_comp()); }
># 842 "/usr/include/c++/8/bits/stl_multimap.h" 3
> iterator
> find(const key_type& __x)
> { return _M_t.find(__x); }
>
>
> template<typename _Kt>
> auto
> find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
> { return _M_t._M_find_tr(__x); }
># 866 "/usr/include/c++/8/bits/stl_multimap.h" 3
> const_iterator
> find(const key_type& __x) const
> { return _M_t.find(__x); }
>
>
> template<typename _Kt>
> auto
> find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
> { return _M_t._M_find_tr(__x); }
># 884 "/usr/include/c++/8/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); }
># 908 "/usr/include/c++/8/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)); }
># 933 "/usr/include/c++/8/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)); }
># 953 "/usr/include/c++/8/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)); }
># 973 "/usr/include/c++/8/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)); }
># 1000 "/usr/include/c++/8/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)); }
># 1027 "/usr/include/c++/8/bits/stl_multimap.h" 3
> std::pair<const_iterator, const_iterator>
> equal_range(const key_type& __x) const
> { return _M_t.equal_range(__x); }
>
>
> template<typename _Kt>
> auto
> equal_range(const _Kt& __x) const
> -> decltype(pair<const_iterator, const_iterator>(
> _M_t._M_equal_range_tr(__x)))
> {
> return pair<const_iterator, const_iterator>(
> _M_t._M_equal_range_tr(__x));
> }
>
>
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator==(const multimap<_K1, _T1, _C1, _A1>&,
> const multimap<_K1, _T1, _C1, _A1>&);
>
> template<typename _K1, typename _T1, typename _C1, typename _A1>
> friend bool
> operator<(const multimap<_K1, _T1, _C1, _A1>&,
> const multimap<_K1, _T1, _C1, _A1>&);
> };
>
>
>
> template<typename _InputIterator,
> typename _Compare = less<__iter_key_t<_InputIterator>>,
> typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
> typename = _RequireInputIter<_InputIterator>,
> typename = _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 = _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>;
># 1098 "/usr/include/c++/8/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; }
># 1115 "/usr/include/c++/8/bits/stl_multimap.h" 3
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __x._M_t < __y._M_t; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline bool
> operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
> inline void
> swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
> multimap<_Key, _Tp, _Compare, _Alloc>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
>
>
>
> template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
> typename _Cmp2>
> struct
> _Rb_tree_merge_helper<std::multimap<_Key, _Val, _Cmp1, _Alloc>,
> _Cmp2>
> {
> private:
> friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>;
>
> static auto&
> _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
> { return __map._M_t; }
>
> static auto&
> _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
> { return __map._M_t; }
> };
>
>
>
>}
># 63 "/usr/include/c++/8/map" 2 3
># 34 "/usr/local/include/nghttp2/asio_http2.h" 2 3
>
># 1 "/usr/include/boost/system/error_code.hpp" 1 3 4
># 14 "/usr/include/boost/system/error_code.hpp" 3 4
># 1 "/usr/include/boost/system/config.hpp" 1 3 4
># 13 "/usr/include/boost/system/config.hpp" 3 4
># 1 "/usr/include/boost/config.hpp" 1 3 4
># 30 "/usr/include/boost/config.hpp" 3 4
># 1 "/usr/include/boost/config/user.hpp" 1 3 4
># 31 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/detail/select_compiler_config.hpp" 1 3 4
># 36 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/compiler/gcc.hpp" 1 3 4
># 165 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
># 1 "/usr/include/c++/8/cstddef" 1 3 4
># 42 "/usr/include/c++/8/cstddef" 3 4
> 
># 43 "/usr/include/c++/8/cstddef" 3
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 51 "/usr/include/c++/8/cstddef" 2 3
>
>
>namespace std
>{
>
> using ::max_align_t;
>}
>
>
>
>namespace std
>{
>
>
>
> enum class byte : unsigned char {};
>
> template<typename _IntegerType> struct __byte_operand { };
> template<> struct __byte_operand<bool> { using __type = byte; };
> template<> struct __byte_operand<char> { using __type = byte; };
> template<> struct __byte_operand<signed char> { using __type = byte; };
> template<> struct __byte_operand<unsigned char> { using __type = byte; };
>
> template<> struct __byte_operand<wchar_t> { using __type = byte; };
>
> template<> struct __byte_operand<char16_t> { using __type = byte; };
> template<> struct __byte_operand<char32_t> { using __type = byte; };
> template<> struct __byte_operand<short> { using __type = byte; };
> template<> struct __byte_operand<unsigned short> { using __type = byte; };
> template<> struct __byte_operand<int> { using __type = byte; };
> template<> struct __byte_operand<unsigned int> { using __type = byte; };
> template<> struct __byte_operand<long> { using __type = byte; };
> template<> struct __byte_operand<unsigned long> { using __type = byte; };
> template<> struct __byte_operand<long long> { using __type = byte; };
> template<> struct __byte_operand<unsigned long long> { using __type = byte; };
># 104 "/usr/include/c++/8/cstddef" 3
> template<typename _IntegerType>
> struct __byte_operand<const _IntegerType>
> : __byte_operand<_IntegerType> { };
> template<typename _IntegerType>
> struct __byte_operand<volatile _IntegerType>
> : __byte_operand<_IntegerType> { };
> template<typename _IntegerType>
> struct __byte_operand<const volatile _IntegerType>
> : __byte_operand<_IntegerType> { };
>
> template<typename _IntegerType>
> using __byte_op_t = typename __byte_operand<_IntegerType>::__type;
>
> template<typename _IntegerType>
> constexpr __byte_op_t<_IntegerType>&
> operator<<=(byte& __b, _IntegerType __shift) noexcept
> { return __b = byte(static_cast<unsigned char>(__b) << __shift); }
>
> template<typename _IntegerType>
> constexpr __byte_op_t<_IntegerType>
> operator<<(byte __b, _IntegerType __shift) noexcept
> { return byte(static_cast<unsigned char>(__b) << __shift); }
>
> template<typename _IntegerType>
> constexpr __byte_op_t<_IntegerType>&
> operator>>=(byte& __b, _IntegerType __shift) noexcept
> { return __b = byte(static_cast<unsigned char>(__b) >> __shift); }
>
> template<typename _IntegerType>
> constexpr __byte_op_t<_IntegerType>
> operator>>(byte __b, _IntegerType __shift) noexcept
> { return byte(static_cast<unsigned char>(__b) >> __shift); }
>
> constexpr byte&
> operator|=(byte& __l, byte __r) noexcept
> {
> return __l =
> byte(static_cast<unsigned char>(__l) | static_cast<unsigned char>(__r));
> }
>
> constexpr byte
> operator|(byte __l, byte __r) noexcept
> {
> return
> byte(static_cast<unsigned char>(__l) | static_cast<unsigned char>(__r));
> }
>
> constexpr byte&
> operator&=(byte& __l, byte __r) noexcept
> {
> return __l =
> byte(static_cast<unsigned char>(__l) & static_cast<unsigned char>(__r));
> }
>
> constexpr byte
> operator&(byte __l, byte __r) noexcept
> {
> return
> byte(static_cast<unsigned char>(__l) & static_cast<unsigned char>(__r));
> }
>
> constexpr byte&
> operator^=(byte& __l, byte __r) noexcept
> {
> return __l =
> byte(static_cast<unsigned char>(__l) ^ static_cast<unsigned char>(__r));
> }
>
> constexpr byte
> operator^(byte __l, byte __r) noexcept
> {
> return
> byte(static_cast<unsigned char>(__l) ^ static_cast<unsigned char>(__r));
> }
>
> constexpr byte
> operator~(byte __b) noexcept
> { return byte(~static_cast<unsigned char>(__b)); }
>
> template<typename _IntegerType>
> constexpr _IntegerType
> to_integer(__byte_op_t<_IntegerType> __b) noexcept
> { return _IntegerType(__b); }
>
>}
># 166 "/usr/include/boost/config/compiler/gcc.hpp" 2 3 4
># 40 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/detail/select_stdlib_config.hpp" 1 3 4
># 45 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
># 78 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
># 1 "/usr/include/unistd.h" 1 3 4
># 27 "/usr/include/unistd.h" 3 4
>extern "C" {
># 202 "/usr/include/unistd.h" 3 4
># 1 "/usr/include/bits/posix_opt.h" 1 3 4
># 203 "/usr/include/unistd.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/environments.h" 1 3 4
># 22 "/usr/include/bits/environments.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 23 "/usr/include/bits/environments.h" 2 3 4
># 207 "/usr/include/unistd.h" 2 3 4
># 226 "/usr/include/unistd.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 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) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int euidaccess (const char *__name, int __type)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int eaccess (const char *__name, int __type)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int faccessat (int __fd, const char *__file, int __type, int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
># 334 "/usr/include/unistd.h" 3 4
>extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
># 345 "/usr/include/unistd.h" 3 4
>extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
> throw ();
>
>
>
>
>
>
>extern int close (int __fd);
>
>
>
>
>
>
>extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;
>
>
>
>
>
>extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
># 376 "/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) ;
># 404 "/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]) throw () ;
>
>
>
>
>extern int pipe2 (int __pipedes[2], int __flags) throw () ;
># 432 "/usr/include/unistd.h" 3 4
>extern unsigned int alarm (unsigned int __seconds) throw ();
># 444 "/usr/include/unistd.h" 3 4
>extern unsigned int sleep (unsigned int __seconds);
>
>
>
>
>
>
>
>extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
> throw ();
>
>
>
>
>
>
>extern int usleep (__useconds_t __useconds);
># 469 "/usr/include/unistd.h" 3 4
>extern int pause (void);
>
>
>
>extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
>
>
>
>
>extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>extern int fchownat (int __fd, const char *__file, __uid_t __owner,
> __gid_t __group, int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int fchdir (int __fd) throw () ;
># 511 "/usr/include/unistd.h" 3 4
>extern char *getcwd (char *__buf, size_t __size) throw () ;
>
>
>
>
>
>extern char *get_current_dir_name (void) throw ();
>
>
>
>
>
>
>
>extern char *getwd (char *__buf)
> throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;
>
>
>
>
>extern int dup (int __fd) throw () ;
>
>
>extern int dup2 (int __fd, int __fd2) throw ();
>
>
>
>
>extern int dup3 (int __fd, int __fd2, int __flags) throw ();
>
>
>
>extern char **__environ;
>
>extern char **environ;
>
>
>
>
>
>extern int execve (const char *__path, char *const __argv[],
> char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int execv (const char *__path, char *const __argv[])
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execle (const char *__path, const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execl (const char *__path, const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int execvp (const char *__file, char *const __argv[])
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execlp (const char *__file, const char *__arg, ...)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>extern int execvpe (const char *__file, char *const __argv[],
> char *const __envp[])
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int nice (int __inc) throw () ;
>
>
>
>
>extern void _exit (int __status) __attribute__ ((__noreturn__));
>
>
>
>
>
># 1 "/usr/include/bits/confname.h" 1 3 4
># 24 "/usr/include/bits/confname.h" 3 4
>enum
> {
> _PC_LINK_MAX,
>
> _PC_MAX_CANON,
>
> _PC_MAX_INPUT,
>
> _PC_NAME_MAX,
>
> _PC_PATH_MAX,
>
> _PC_PIPE_BUF,
>
> _PC_CHOWN_RESTRICTED,
>
> _PC_NO_TRUNC,
>
> _PC_VDISABLE,
>
> _PC_SYNC_IO,
>
> _PC_ASYNC_IO,
>
> _PC_PRIO_IO,
>
> _PC_SOCK_MAXBUF,
>
> _PC_FILESIZEBITS,
>
> _PC_REC_INCR_XFER_SIZE,
>
> _PC_REC_MAX_XFER_SIZE,
>
> _PC_REC_MIN_XFER_SIZE,
>
> _PC_REC_XFER_ALIGN,
>
> _PC_ALLOC_SIZE_MIN,
>
> _PC_SYMLINK_MAX,
>
> _PC_2_SYMLINKS
>
> };
>
>
>enum
> {
> _SC_ARG_MAX,
>
> _SC_CHILD_MAX,
>
> _SC_CLK_TCK,
>
> _SC_NGROUPS_MAX,
>
> _SC_OPEN_MAX,
>
> _SC_STREAM_MAX,
>
> _SC_TZNAME_MAX,
>
> _SC_JOB_CONTROL,
>
> _SC_SAVED_IDS,
>
> _SC_REALTIME_SIGNALS,
>
> _SC_PRIORITY_SCHEDULING,
>
> _SC_TIMERS,
>
> _SC_ASYNCHRONOUS_IO,
>
> _SC_PRIORITIZED_IO,
>
> _SC_SYNCHRONIZED_IO,
>
> _SC_FSYNC,
>
> _SC_MAPPED_FILES,
>
> _SC_MEMLOCK,
>
> _SC_MEMLOCK_RANGE,
>
> _SC_MEMORY_PROTECTION,
>
> _SC_MESSAGE_PASSING,
>
> _SC_SEMAPHORES,
>
> _SC_SHARED_MEMORY_OBJECTS,
>
> _SC_AIO_LISTIO_MAX,
>
> _SC_AIO_MAX,
>
> _SC_AIO_PRIO_DELTA_MAX,
>
> _SC_DELAYTIMER_MAX,
>
> _SC_MQ_OPEN_MAX,
>
> _SC_MQ_PRIO_MAX,
>
> _SC_VERSION,
>
> _SC_PAGESIZE,
>
>
> _SC_RTSIG_MAX,
>
> _SC_SEM_NSEMS_MAX,
>
> _SC_SEM_VALUE_MAX,
>
> _SC_SIGQUEUE_MAX,
>
> _SC_TIMER_MAX,
>
>
>
>
> _SC_BC_BASE_MAX,
>
> _SC_BC_DIM_MAX,
>
> _SC_BC_SCALE_MAX,
>
> _SC_BC_STRING_MAX,
>
> _SC_COLL_WEIGHTS_MAX,
>
> _SC_EQUIV_CLASS_MAX,
>
> _SC_EXPR_NEST_MAX,
>
> _SC_LINE_MAX,
>
> _SC_RE_DUP_MAX,
>
> _SC_CHARCLASS_NAME_MAX,
>
>
> _SC_2_VERSION,
>
> _SC_2_C_BIND,
>
> _SC_2_C_DEV,
>
> _SC_2_FORT_DEV,
>
> _SC_2_FORT_RUN,
>
> _SC_2_SW_DEV,
>
> _SC_2_LOCALEDEF,
>
>
> _SC_PII,
>
> _SC_PII_XTI,
>
> _SC_PII_SOCKET,
>
> _SC_PII_INTERNET,
>
> _SC_PII_OSI,
>
> _SC_POLL,
>
> _SC_SELECT,
>
> _SC_UIO_MAXIOV,
>
> _SC_IOV_MAX = _SC_UIO_MAXIOV,
>
> _SC_PII_INTERNET_STREAM,
>
> _SC_PII_INTERNET_DGRAM,
>
> _SC_PII_OSI_COTS,
>
> _SC_PII_OSI_CLTS,
>
> _SC_PII_OSI_M,
>
> _SC_T_IOV_MAX,
>
>
>
> _SC_THREADS,
>
> _SC_THREAD_SAFE_FUNCTIONS,
>
> _SC_GETGR_R_SIZE_MAX,
>
> _SC_GETPW_R_SIZE_MAX,
>
> _SC_LOGIN_NAME_MAX,
>
> _SC_TTY_NAME_MAX,
>
> _SC_THREAD_DESTRUCTOR_ITERATIONS,
>
> _SC_THREAD_KEYS_MAX,
>
> _SC_THREAD_STACK_MIN,
>
> _SC_THREAD_THREADS_MAX,
>
> _SC_THREAD_ATTR_STACKADDR,
>
> _SC_THREAD_ATTR_STACKSIZE,
>
> _SC_THREAD_PRIORITY_SCHEDULING,
>
> _SC_THREAD_PRIO_INHERIT,
>
> _SC_THREAD_PRIO_PROTECT,
>
> _SC_THREAD_PROCESS_SHARED,
>
>
> _SC_NPROCESSORS_CONF,
>
> _SC_NPROCESSORS_ONLN,
>
> _SC_PHYS_PAGES,
>
> _SC_AVPHYS_PAGES,
>
> _SC_ATEXIT_MAX,
>
> _SC_PASS_MAX,
>
>
> _SC_XOPEN_VERSION,
>
> _SC_XOPEN_XCU_VERSION,
>
> _SC_XOPEN_UNIX,
>
> _SC_XOPEN_CRYPT,
>
> _SC_XOPEN_ENH_I18N,
>
> _SC_XOPEN_SHM,
>
>
> _SC_2_CHAR_TERM,
>
> _SC_2_C_VERSION,
>
> _SC_2_UPE,
>
>
> _SC_XOPEN_XPG2,
>
> _SC_XOPEN_XPG3,
>
> _SC_XOPEN_XPG4,
>
>
> _SC_CHAR_BIT,
>
> _SC_CHAR_MAX,
>
> _SC_CHAR_MIN,
>
> _SC_INT_MAX,
>
> _SC_INT_MIN,
>
> _SC_LONG_BIT,
>
> _SC_WORD_BIT,
>
> _SC_MB_LEN_MAX,
>
> _SC_NZERO,
>
> _SC_SSIZE_MAX,
>
> _SC_SCHAR_MAX,
>
> _SC_SCHAR_MIN,
>
> _SC_SHRT_MAX,
>
> _SC_SHRT_MIN,
>
> _SC_UCHAR_MAX,
>
> _SC_UINT_MAX,
>
> _SC_ULONG_MAX,
>
> _SC_USHRT_MAX,
>
>
> _SC_NL_ARGMAX,
>
> _SC_NL_LANGMAX,
>
> _SC_NL_MSGMAX,
>
> _SC_NL_NMAX,
>
> _SC_NL_SETMAX,
>
> _SC_NL_TEXTMAX,
>
>
> _SC_XBS5_ILP32_OFF32,
>
> _SC_XBS5_ILP32_OFFBIG,
>
> _SC_XBS5_LP64_OFF64,
>
> _SC_XBS5_LPBIG_OFFBIG,
>
>
> _SC_XOPEN_LEGACY,
>
> _SC_XOPEN_REALTIME,
>
> _SC_XOPEN_REALTIME_THREADS,
>
>
> _SC_ADVISORY_INFO,
>
> _SC_BARRIERS,
>
> _SC_BASE,
>
> _SC_C_LANG_SUPPORT,
>
> _SC_C_LANG_SUPPORT_R,
>
> _SC_CLOCK_SELECTION,
>
> _SC_CPUTIME,
>
> _SC_THREAD_CPUTIME,
>
> _SC_DEVICE_IO,
>
> _SC_DEVICE_SPECIFIC,
>
> _SC_DEVICE_SPECIFIC_R,
>
> _SC_FD_MGMT,
>
> _SC_FIFO,
>
> _SC_PIPE,
>
> _SC_FILE_ATTRIBUTES,
>
> _SC_FILE_LOCKING,
>
> _SC_FILE_SYSTEM,
>
> _SC_MONOTONIC_CLOCK,
>
> _SC_MULTI_PROCESS,
>
> _SC_SINGLE_PROCESS,
>
> _SC_NETWORKING,
>
> _SC_READER_WRITER_LOCKS,
>
> _SC_SPIN_LOCKS,
>
> _SC_REGEXP,
>
> _SC_REGEX_VERSION,
>
> _SC_SHELL,
>
> _SC_SIGNALS,
>
> _SC_SPAWN,
>
> _SC_SPORADIC_SERVER,
>
> _SC_THREAD_SPORADIC_SERVER,
>
> _SC_SYSTEM_DATABASE,
>
> _SC_SYSTEM_DATABASE_R,
>
> _SC_TIMEOUTS,
>
> _SC_TYPED_MEMORY_OBJECTS,
>
> _SC_USER_GROUPS,
>
> _SC_USER_GROUPS_R,
>
> _SC_2_PBS,
>
> _SC_2_PBS_ACCOUNTING,
>
> _SC_2_PBS_LOCATE,
>
> _SC_2_PBS_MESSAGE,
>
> _SC_2_PBS_TRACK,
>
> _SC_SYMLOOP_MAX,
>
> _SC_STREAMS,
>
> _SC_2_PBS_CHECKPOINT,
>
>
> _SC_V6_ILP32_OFF32,
>
> _SC_V6_ILP32_OFFBIG,
>
> _SC_V6_LP64_OFF64,
>
> _SC_V6_LPBIG_OFFBIG,
>
>
> _SC_HOST_NAME_MAX,
>
> _SC_TRACE,
>
> _SC_TRACE_EVENT_FILTER,
>
> _SC_TRACE_INHERIT,
>
> _SC_TRACE_LOG,
>
>
> _SC_LEVEL1_ICACHE_SIZE,
>
> _SC_LEVEL1_ICACHE_ASSOC,
>
> _SC_LEVEL1_ICACHE_LINESIZE,
>
> _SC_LEVEL1_DCACHE_SIZE,
>
> _SC_LEVEL1_DCACHE_ASSOC,
>
> _SC_LEVEL1_DCACHE_LINESIZE,
>
> _SC_LEVEL2_CACHE_SIZE,
>
> _SC_LEVEL2_CACHE_ASSOC,
>
> _SC_LEVEL2_CACHE_LINESIZE,
>
> _SC_LEVEL3_CACHE_SIZE,
>
> _SC_LEVEL3_CACHE_ASSOC,
>
> _SC_LEVEL3_CACHE_LINESIZE,
>
> _SC_LEVEL4_CACHE_SIZE,
>
> _SC_LEVEL4_CACHE_ASSOC,
>
> _SC_LEVEL4_CACHE_LINESIZE,
>
>
>
> _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
>
> _SC_RAW_SOCKETS,
>
>
> _SC_V7_ILP32_OFF32,
>
> _SC_V7_ILP32_OFFBIG,
>
> _SC_V7_LP64_OFF64,
>
> _SC_V7_LPBIG_OFFBIG,
>
>
> _SC_SS_REPL_MAX,
>
>
> _SC_TRACE_EVENT_NAME_MAX,
>
> _SC_TRACE_NAME_MAX,
>
> _SC_TRACE_SYS_MAX,
>
> _SC_TRACE_USER_EVENT_MAX,
>
>
> _SC_XOPEN_STREAMS,
>
>
> _SC_THREAD_ROBUST_PRIO_INHERIT,
>
> _SC_THREAD_ROBUST_PRIO_PROTECT
>
> };
>
>
>enum
> {
> _CS_PATH,
>
>
> _CS_V6_WIDTH_RESTRICTED_ENVS,
>
>
>
> _CS_GNU_LIBC_VERSION,
>
> _CS_GNU_LIBPTHREAD_VERSION,
>
>
> _CS_V5_WIDTH_RESTRICTED_ENVS,
>
>
>
> _CS_V7_WIDTH_RESTRICTED_ENVS,
>
>
>
> _CS_LFS_CFLAGS = 1000,
>
> _CS_LFS_LDFLAGS,
>
> _CS_LFS_LIBS,
>
> _CS_LFS_LINTFLAGS,
>
> _CS_LFS64_CFLAGS,
>
> _CS_LFS64_LDFLAGS,
>
> _CS_LFS64_LIBS,
>
> _CS_LFS64_LINTFLAGS,
>
>
> _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
>
> _CS_XBS5_ILP32_OFF32_LDFLAGS,
>
> _CS_XBS5_ILP32_OFF32_LIBS,
>
> _CS_XBS5_ILP32_OFF32_LINTFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_CFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
>
> _CS_XBS5_ILP32_OFFBIG_LIBS,
>
> _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_XBS5_LP64_OFF64_CFLAGS,
>
> _CS_XBS5_LP64_OFF64_LDFLAGS,
>
> _CS_XBS5_LP64_OFF64_LIBS,
>
> _CS_XBS5_LP64_OFF64_LINTFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_XBS5_LPBIG_OFFBIG_LIBS,
>
> _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
>
> _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
>
> _CS_POSIX_V6_ILP32_OFF32_LIBS,
>
> _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
>
> _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_CFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
>
> _CS_POSIX_V6_LP64_OFF64_LIBS,
>
> _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
>
> _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
>
> _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
>
> _CS_POSIX_V7_ILP32_OFF32_LIBS,
>
> _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
>
> _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
>
> _CS_POSIX_V7_LP64_OFF64_CFLAGS,
>
> _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
>
> _CS_POSIX_V7_LP64_OFF64_LIBS,
>
> _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
>
> _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
>
>
> _CS_V6_ENV,
>
> _CS_V7_ENV
>
> };
># 610 "/usr/include/unistd.h" 2 3 4
>
>
>extern long int pathconf (const char *__path, int __name)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern long int fpathconf (int __fd, int __name) throw ();
>
>
>extern long int sysconf (int __name) throw ();
>
>
>
>extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
>
>
>
>
>extern __pid_t getpid (void) throw ();
>
>
>extern __pid_t getppid (void) throw ();
>
>
>extern __pid_t getpgrp (void) throw ();
>
>
>extern __pid_t __getpgid (__pid_t __pid) throw ();
>
>extern __pid_t getpgid (__pid_t __pid) throw ();
>
>
>
>
>
>
>extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
># 660 "/usr/include/unistd.h" 3 4
>extern int setpgrp (void) throw ();
>
>
>
>
>
>
>extern __pid_t setsid (void) throw ();
>
>
>
>extern __pid_t getsid (__pid_t __pid) throw ();
>
>
>
>extern __uid_t getuid (void) throw ();
>
>
>extern __uid_t geteuid (void) throw ();
>
>
>extern __gid_t getgid (void) throw ();
>
>
>extern __gid_t getegid (void) throw ();
>
>
>
>
>extern int getgroups (int __size, __gid_t __list[]) throw () ;
>
>
>
>extern int group_member (__gid_t __gid) throw ();
>
>
>
>
>
>
>extern int setuid (__uid_t __uid) throw () ;
>
>
>
>
>extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
>
>
>
>
>extern int seteuid (__uid_t __uid) throw () ;
>
>
>
>
>
>
>extern int setgid (__gid_t __gid) throw () ;
>
>
>
>
>extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
>
>
>
>
>extern int setegid (__gid_t __gid) throw () ;
>
>
>
>
>
>extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
> throw ();
>
>
>
>extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
> throw ();
>
>
>
>extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
> throw () ;
>
>
>
>extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
> throw () ;
>
>
>
>
>
>
>extern __pid_t fork (void) throw ();
>
>
>
>
>
>
>
>extern __pid_t vfork (void) throw ();
>
>
>
>
>
>extern char *ttyname (int __fd) throw ();
>
>
>
>extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>extern int isatty (int __fd) throw ();
>
>
>
>
>extern int ttyslot (void) throw ();
>
>
>
>
>extern int link (const char *__from, const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int linkat (int __fromfd, const char *__from, int __tofd,
> const char *__to, int __flags)
> throw () __attribute__ ((__nonnull__ (2, 4))) ;
>
>
>
>
>extern int symlink (const char *__from, const char *__to)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern ssize_t readlink (const char *__restrict __path,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (1, 2))) ;
>
>
>
>
>extern int symlinkat (const char *__from, int __tofd,
> const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
>
>
>extern ssize_t readlinkat (int __fd, const char *__restrict __path,
> char *__restrict __buf, size_t __len)
> throw () __attribute__ ((__nonnull__ (2, 3))) ;
>
>
>
>extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int unlinkat (int __fd, const char *__name, int __flag)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern __pid_t tcgetpgrp (int __fd) throw ();
>
>
>extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
>
>
>
>
>
>
>extern char *getlogin (void);
>
>
>
>
>
>
>
>extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
># 1 "/usr/include/bits/getopt_posix.h" 1 3 4
># 27 "/usr/include/bits/getopt_posix.h" 3 4
># 1 "/usr/include/bits/getopt_core.h" 1 3 4
># 28 "/usr/include/bits/getopt_core.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
>extern char *optarg;
># 50 "/usr/include/bits/getopt_core.h" 3 4
>extern int optind;
>
>
>
>
>extern int opterr;
>
>
>
>extern int optopt;
># 91 "/usr/include/bits/getopt_core.h" 3 4
>extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>}
># 28 "/usr/include/bits/getopt_posix.h" 2 3 4
>
>extern "C" {
># 49 "/usr/include/bits/getopt_posix.h" 3 4
>}
># 870 "/usr/include/unistd.h" 2 3 4
>
>
>
>
>
>
>
>extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sethostname (const char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern int sethostid (long int __id) throw () ;
>
>
>
>
>
>extern int getdomainname (char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>extern int setdomainname (const char *__name, size_t __len)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>extern int vhangup (void) throw ();
>
>
>extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>
>
>
>
>extern int profil (unsigned short int *__sample_buffer, size_t __size,
> size_t __offset, unsigned int __scale)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int acct (const char *__name) throw ();
>
>
>
>extern char *getusershell (void) throw ();
>extern void endusershell (void) throw ();
>extern void setusershell (void) throw ();
>
>
>
>
>
>extern int daemon (int __nochdir, int __noclose) throw () ;
>
>
>
>
>
>
>extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
>
>
>
>extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int fsync (int __fd);
>
>
>
>
>
>extern int syncfs (int __fd) throw ();
>
>
>
>
>
>
>extern long int gethostid (void);
>
>
>extern void sync (void) throw ();
>
>
>
>
>
>extern int getpagesize (void) throw () __attribute__ ((__const__));
>
>
>
>
>extern int getdtablesize (void) throw ();
># 991 "/usr/include/unistd.h" 3 4
>extern int truncate (const char *__file, __off_t __length)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 1003 "/usr/include/unistd.h" 3 4
>extern int truncate64 (const char *__file, __off64_t __length)
> throw () __attribute__ ((__nonnull__ (1))) ;
># 1014 "/usr/include/unistd.h" 3 4
>extern int ftruncate (int __fd, __off_t __length) throw () ;
># 1024 "/usr/include/unistd.h" 3 4
>extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
># 1035 "/usr/include/unistd.h" 3 4
>extern int brk (void *__addr) throw () ;
>
>
>
>
>
>extern void *sbrk (intptr_t __delta) throw ();
># 1056 "/usr/include/unistd.h" 3 4
>extern long int syscall (long int __sysno, ...) throw ();
># 1079 "/usr/include/unistd.h" 3 4
>extern int lockf (int __fd, int __cmd, __off_t __len) ;
># 1089 "/usr/include/unistd.h" 3 4
>extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
># 1107 "/usr/include/unistd.h" 3 4
>ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
> int __outfd, __off64_t *__poutoff,
> size_t __length, unsigned int __flags);
>
>
>
>
>
>extern int fdatasync (int __fildes);
>
>
>
>
>
>
>
>extern void swab (const void *__restrict __from, void *__restrict __to,
> ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
># 1151 "/usr/include/unistd.h" 3 4
>int getentropy (void *__buffer, size_t __length) ;
>
>
>
>
>
>
>
>}
># 79 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 2 3 4
># 49 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/config/detail/select_platform_config.hpp" 1 3 4
># 54 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
># 15 "/usr/include/boost/config/platform/linux.hpp" 3 4
># 1 "/usr/include/c++/8/cstdlib" 1 3 4
># 39 "/usr/include/c++/8/cstdlib" 3 4
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 16 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
># 75 "/usr/include/boost/config/platform/linux.hpp" 3 4
># 1 "/usr/include/boost/config/detail/posix_features.hpp" 1 3 4
># 76 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
># 58 "/usr/include/boost/config.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/config/detail/suffix.hpp" 1 3 4
># 34 "/usr/include/boost/config/detail/suffix.hpp" 3 4
> 
># 35 "/usr/include/boost/config/detail/suffix.hpp" 3
># 484 "/usr/include/boost/config/detail/suffix.hpp" 3
>namespace boost{
>
> __extension__ typedef long long long_long_type;
> __extension__ typedef unsigned long long ulong_long_type;
>
>
>
>
>}
>
>
>
>namespace boost{
>
> __extension__ typedef __int128 int128_type;
> __extension__ typedef unsigned __int128 uint128_type;
>
>
>
>
>}
># 62 "/usr/include/boost/config.hpp" 2 3 4
>
>
> 
># 14 "/usr/include/boost/system/config.hpp" 2 3 4
># 1 "/usr/include/boost/predef/platform.h" 1 3 4
># 14 "/usr/include/boost/predef/platform.h" 3 4
># 1 "/usr/include/boost/predef/platform/cloudabi.h" 1 3 4
># 11 "/usr/include/boost/predef/platform/cloudabi.h" 3 4
># 1 "/usr/include/boost/predef/version_number.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/cloudabi.h" 2 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/predef/detail/test.h" 1 3 4
># 8 "/usr/include/boost/predef/make.h" 2 3 4
># 13 "/usr/include/boost/predef/platform/cloudabi.h" 2 3 4
># 43 "/usr/include/boost/predef/platform/cloudabi.h" 3 4
>
># 15 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/mingw.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/mingw.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/mingw.h" 2 3 4
># 64 "/usr/include/boost/predef/platform/mingw.h" 3 4
>
># 16 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/mingw32.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/mingw32.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/mingw32.h" 2 3 4
># 58 "/usr/include/boost/predef/platform/mingw32.h" 3 4
>
># 17 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/mingw64.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/mingw64.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/mingw64.h" 2 3 4
># 58 "/usr/include/boost/predef/platform/mingw64.h" 3 4
>
># 18 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
># 11 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_uwp.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 12 "/usr/include/boost/predef/os/windows.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/windows.h" 2 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 13 "/usr/include/boost/predef/platform/windows_uwp.h" 2 3 4
># 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
>
># 19 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_desktop.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_desktop.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/windows_desktop.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 14 "/usr/include/boost/predef/platform/windows_desktop.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
># 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
>
># 15 "/usr/include/boost/predef/platform/windows_desktop.h" 2 3 4
># 51 "/usr/include/boost/predef/platform/windows_desktop.h" 3 4
>
># 20 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_phone.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 14 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
># 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
>
># 15 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
># 48 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
>
># 21 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_server.h" 1 3 4
># 11 "/usr/include/boost/predef/platform/windows_server.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_server.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 13 "/usr/include/boost/predef/platform/windows_server.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
># 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
>
># 14 "/usr/include/boost/predef/platform/windows_server.h" 2 3 4
># 47 "/usr/include/boost/predef/platform/windows_server.h" 3 4
>
># 22 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_store.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_store.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 14 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
># 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
>
># 15 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
># 50 "/usr/include/boost/predef/platform/windows_store.h" 3 4
>
># 23 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_system.h" 1 3 4
># 11 "/usr/include/boost/predef/platform/windows_system.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_system.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 13 "/usr/include/boost/predef/platform/windows_system.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
># 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
>
># 14 "/usr/include/boost/predef/platform/windows_system.h" 2 3 4
># 47 "/usr/include/boost/predef/platform/windows_system.h" 3 4
>
># 24 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_runtime.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/windows_runtime.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 14 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_phone.h" 1 3 4
># 48 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
>
># 15 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/windows_store.h" 1 3 4
># 50 "/usr/include/boost/predef/platform/windows_store.h" 3 4
>
># 16 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
># 53 "/usr/include/boost/predef/platform/windows_runtime.h" 3 4
>
># 25 "/usr/include/boost/predef/platform.h" 2 3 4
># 1 "/usr/include/boost/predef/platform/ios.h" 1 3 4
># 12 "/usr/include/boost/predef/platform/ios.h" 3 4
># 1 "/usr/include/boost/predef/os/ios.h" 1 3 4
># 13 "/usr/include/boost/predef/os/ios.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 14 "/usr/include/boost/predef/os/ios.h" 2 3 4
># 51 "/usr/include/boost/predef/os/ios.h" 3 4
>
># 13 "/usr/include/boost/predef/platform/ios.h" 2 3 4
># 57 "/usr/include/boost/predef/platform/ios.h" 3 4
>
>
># 26 "/usr/include/boost/predef/platform.h" 2 3 4
># 15 "/usr/include/boost/system/config.hpp" 2 3 4
># 1 "/usr/include/boost/system/api_config.hpp" 1 3 4
># 16 "/usr/include/boost/system/config.hpp" 2 3 4
># 66 "/usr/include/boost/system/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 67 "/usr/include/boost/system/config.hpp" 2 3 4
># 15 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 103 "/usr/include/boost/cstdint.hpp" 3 4
>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;
>
>}
># 376 "/usr/include/boost/cstdint.hpp" 3 4
>namespace boost {
> using ::intptr_t;
> using ::uintptr_t;
>}
># 16 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 58 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 59 "/usr/include/boost/assert.hpp" 2 3 4
># 17 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/noncopyable.hpp" 1 3 4
># 15 "/usr/include/boost/noncopyable.hpp" 3 4
># 1 "/usr/include/boost/core/noncopyable.hpp" 1 3 4
># 14 "/usr/include/boost/core/noncopyable.hpp" 3 4
>namespace boost {
>
>
>
>
>
>
>namespace noncopyable_
>{
> class noncopyable
> {
> protected:
>
> constexpr noncopyable() = default;
> ~noncopyable() = default;
>
>
>
>
>
> noncopyable( const noncopyable& ) = delete;
> noncopyable& operator=( const noncopyable& ) = delete;
>
>
>
>
>
> };
>}
>
>typedef noncopyable_::noncopyable noncopyable;
>
>}
># 16 "/usr/include/boost/noncopyable.hpp" 2 3 4
># 18 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 1 "/usr/include/boost/utility/enable_if.hpp" 1 3 4
># 15 "/usr/include/boost/utility/enable_if.hpp" 3 4
># 1 "/usr/include/boost/core/enable_if.hpp" 1 3 4
># 24 "/usr/include/boost/core/enable_if.hpp" 3 4
>namespace boost
>{
> template<typename T, typename R=void>
> struct enable_if_has_type
> {
> typedef R type;
> };
>
> template <bool B, class T = void>
> struct enable_if_c {
> typedef T type;
> };
>
> template <class T>
> struct enable_if_c<false, T> {};
>
> template <class Cond, class T = void>
> struct enable_if : public enable_if_c<Cond::value, T> {};
>
> template <bool B, class T>
> struct lazy_enable_if_c {
> typedef typename T::type type;
> };
>
> template <class T>
> struct lazy_enable_if_c<false, T> {};
>
> template <class Cond, class T>
> struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
>
>
> template <bool B, class T = void>
> struct disable_if_c {
> typedef T type;
> };
>
> template <class T>
> struct disable_if_c<true, T> {};
>
> template <class Cond, class T = void>
> struct disable_if : public disable_if_c<Cond::value, T> {};
>
> template <bool B, class T>
> struct lazy_disable_if_c {
> typedef typename T::type type;
> };
>
> template <class T>
> struct lazy_disable_if_c<true, T> {};
>
> template <class Cond, class T>
> struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
>
>}
># 16 "/usr/include/boost/utility/enable_if.hpp" 2 3 4
># 19 "/usr/include/boost/system/error_code.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/cerrno.hpp" 1 3 4
># 13 "/usr/include/boost/cerrno.hpp" 3 4
># 1 "/usr/include/c++/8/cerrno" 1 3 4
># 39 "/usr/include/c++/8/cerrno" 3 4
> 
># 40 "/usr/include/c++/8/cerrno" 3
># 14 "/usr/include/boost/cerrno.hpp" 2 3 4
># 26 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 35 "/usr/include/boost/system/error_code.hpp" 3 4
># 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
># 36 "/usr/include/boost/system/error_code.hpp" 2 3 4
>
>
>
>
>
>namespace boost
>{
> namespace system
> {
>
> class error_code;
> class error_condition;
>
>
>
>
> template< class T >
> struct is_error_code_enum { static const bool value = false; };
>
> template< class T >
> struct is_error_condition_enum { static const bool value = false; };
>
>
>
> namespace errc
> {
> enum errc_t
> {
> success = 0,
> address_family_not_supported = 97,
> address_in_use = 98,
> address_not_available = 99,
> already_connected = 106,
> argument_list_too_long = 7,
> argument_out_of_domain = 33,
> bad_address = 14,
> bad_file_descriptor = 9,
> bad_message = 74,
> broken_pipe = 32,
> connection_aborted = 103,
> connection_already_in_progress = 114,
> connection_refused = 111,
> connection_reset = 104,
> cross_device_link = 18,
> destination_address_required = 89,
> device_or_resource_busy = 16,
> directory_not_empty = 39,
> executable_format_error = 8,
> file_exists = 17,
> file_too_large = 27,
> filename_too_long = 36,
> function_not_supported = 38,
> host_unreachable = 113,
> identifier_removed = 43,
> illegal_byte_sequence = 84,
> inappropriate_io_control_operation = 25,
> interrupted = 4,
> invalid_argument = 22,
> invalid_seek = 29,
> io_error = 5,
> is_a_directory = 21,
> message_size = 90,
> network_down = 100,
> network_reset = 102,
> network_unreachable = 101,
> no_buffer_space = 105,
> no_child_process = 10,
> no_link = 67,
> no_lock_available = 37,
> no_message_available = 61,
> no_message = 42,
> no_protocol_option = 92,
> no_space_on_device = 28,
> no_stream_resources = 63,
> no_such_device_or_address = 6,
> no_such_device = 19,
> no_such_file_or_directory = 2,
> no_such_process = 3,
> not_a_directory = 20,
> not_a_socket = 88,
> not_a_stream = 60,
> not_connected = 107,
> not_enough_memory = 12,
> not_supported = 95,
> operation_canceled = 125,
> operation_in_progress = 115,
> operation_not_permitted = 1,
> operation_not_supported = 95,
> operation_would_block = 11,
> owner_dead = 130,
> permission_denied = 13,
> protocol_error = 71,
> protocol_not_supported = 93,
> read_only_file_system = 30,
> resource_deadlock_would_occur = 35,
> resource_unavailable_try_again = 11,
> result_out_of_range = 34,
> state_not_recoverable = 131,
> stream_timeout = 62,
> text_file_busy = 26,
> timed_out = 110,
> too_many_files_open_in_system = 23,
> too_many_files_open = 24,
> too_many_links = 31,
> too_many_symbolic_link_levels = 40,
> value_too_large = 75,
> wrong_protocol_type = 91
> };
>
> }
>
>
>
>
>
>
> template<> struct is_error_condition_enum<errc::errc_t>
> { static const bool value = true; };
># 188 "/usr/include/boost/system/error_code.hpp" 3 4
> class error_category;
>
>
>
>
>
>
>
> const error_category & system_category() noexcept;
> const error_category & generic_category() noexcept;
># 221 "/usr/include/boost/system/error_code.hpp" 3 4
> class error_category : public noncopyable
> {
>
>
> private:
>
> class std_category: public std::error_category
> {
> private:
>
> boost::system::error_category const * pc_;
>
> public:
>
> explicit std_category( boost::system::error_category const * pc ): pc_( pc )
> {
> }
>
> virtual const char * name() const noexcept
> {
> return pc_->name();
> }
>
> virtual std::string message( int ev ) const
> {
> return pc_->message( ev );
> }
>
> virtual std::error_condition default_error_condition( int ev ) const
> noexcept;
> virtual bool equivalent( int code, const std::error_condition & condition ) const
> noexcept;
> virtual bool equivalent( const std::error_code & code, int condition ) const
> noexcept;
> };
>
> std_category std_cat_;
>
> public:
>
> error_category() noexcept: std_cat_( this ) {}
>
> operator std::error_category const & () const noexcept
> {
>
>
>
> return std_cat_;
> }
># 316 "/usr/include/boost/system/error_code.hpp" 3 4
> public:
> virtual ~error_category(){}
>
> virtual const char * name() const noexcept = 0;
> virtual std::string message( int ev ) const = 0;
> inline virtual error_condition default_error_condition( int ev ) const
> noexcept;
> inline virtual bool equivalent( int code,
> const error_condition & condition ) const
> noexcept;
> inline virtual bool equivalent( const error_code & code,
> int condition ) const noexcept;
>
> bool operator==(const error_category & rhs) const noexcept
> { return this == &rhs; }
> bool operator!=(const error_category & rhs) const noexcept
> { return this != &rhs; }
> bool operator<( const error_category & rhs ) const noexcept
> { return std::less<const error_category*>()( this, &rhs ); }
> };
># 345 "/usr/include/boost/system/error_code.hpp" 3 4
> class error_condition
> {
> public:
>
>
> error_condition() noexcept : m_val(0), m_cat(&generic_category()) {}
> error_condition( int val, const error_category & cat ) noexcept
> : m_val(val), m_cat(&cat) {}
>
> template <class ErrorConditionEnum>
> error_condition(ErrorConditionEnum e,
> typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type*
> = 0) noexcept
> {
> *this = make_error_condition(e);
> }
>
>
>
> void assign( int val, const error_category & cat ) noexcept
> {
> m_val = val;
> m_cat = &cat;
> }
>
> template<typename ErrorConditionEnum>
> typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>,
> error_condition>::type &
> operator=( ErrorConditionEnum val ) noexcept
> {
> *this = make_error_condition(val);
> return *this;
> }
>
> void clear() noexcept
> {
> m_val = 0;
> m_cat = &generic_category();
> }
>
>
> int value() const noexcept { return m_val; }
> const error_category & category() const noexcept { return *m_cat; }
> std::string message() const { return m_cat->message(value()); }
>
> typedef void (*unspecified_bool_type)();
> static void unspecified_bool_true() {}
>
> operator unspecified_bool_type() const noexcept
> {
> return m_val == 0 ? 0 : unspecified_bool_true;
> }
>
> bool operator!() const noexcept
> {
> return m_val == 0;
> }
>
>
>
>
> inline friend bool operator==( const error_condition & lhs,
> const error_condition & rhs ) noexcept
> {
> return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
> }
>
> inline friend bool operator<( const error_condition & lhs,
> const error_condition & rhs ) noexcept
>
>
> {
> return lhs.m_cat < rhs.m_cat
> || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
> }
>
>
>
> operator std::error_condition () const noexcept
> {
> return std::error_condition( value(), category() );
> }
>
>
>
> private:
> int m_val;
> const error_category * m_cat;
>
> };
># 444 "/usr/include/boost/system/error_code.hpp" 3 4
> class error_code
> {
> public:
>
>
> error_code() noexcept : m_val(0), m_cat(&system_category()) {}
> error_code( int val, const error_category & cat ) noexcept
> : m_val(val), m_cat(&cat) {}
>
> template <class ErrorCodeEnum>
> error_code(ErrorCodeEnum e,
> typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
> noexcept
> {
> *this = make_error_code(e);
> }
>
>
> void assign( int val, const error_category & cat ) noexcept
> {
> m_val = val;
> m_cat = &cat;
> }
>
> template<typename ErrorCodeEnum>
> typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
> operator=( ErrorCodeEnum val ) noexcept
> {
> *this = make_error_code(val);
> return *this;
> }
>
> void clear() noexcept
> {
> m_val = 0;
> m_cat = &system_category();
> }
>
>
> int value() const noexcept { return m_val; }
> const error_category & category() const noexcept { return *m_cat; }
> error_condition default_error_condition() const noexcept
> { return m_cat->default_error_condition(value()); }
> std::string message() const { return m_cat->message(value()); }
>
> typedef void (*unspecified_bool_type)();
> static void unspecified_bool_true() {}
>
> operator unspecified_bool_type() const noexcept
> {
> return m_val == 0 ? 0 : unspecified_bool_true;
> }
>
> bool operator!() const noexcept
> {
> return m_val == 0;
> }
>
>
> inline friend bool operator==( const error_code & lhs,
> const error_code & rhs ) noexcept
>
>
> {
> return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
> }
>
> inline friend bool operator<( const error_code & lhs,
> const error_code & rhs ) noexcept
>
>
> {
> return lhs.m_cat < rhs.m_cat
> || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
> }
>
>
>
> operator std::error_code () const noexcept
> {
> return std::error_code( value(), category() );
> }
>
>
>
> private:
> int m_val;
> const error_category * m_cat;
>
> };
># 544 "/usr/include/boost/system/error_code.hpp" 3 4
> }
>
> namespace detail
> {
>
>
>
>
>
>
>
> inline system::error_code* throws()
> {
>
>
>
>
> return reinterpret_cast<system::error_code*>(1);
> }
> }
>
> inline system::error_code& throws()
> { return *detail::throws(); }
>
> namespace system
> {
>
>
> inline bool operator!=( const error_code & lhs,
> const error_code & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
> inline bool operator!=( const error_condition & lhs,
> const error_condition & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
> inline bool operator==( const error_code & code,
> const error_condition & condition ) noexcept
> {
> return code.category().equivalent( code.value(), condition )
> || condition.category().equivalent( code, condition.value() );
> }
>
> inline bool operator!=( const error_code & lhs,
> const error_condition & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
> inline bool operator==( const error_condition & condition,
> const error_code & code ) noexcept
> {
> return condition.category().equivalent( code, condition.value() )
> || code.category().equivalent( code.value(), condition );
> }
>
> inline bool operator!=( const error_condition & lhs,
> const error_code & rhs ) noexcept
> {
> return !(lhs == rhs);
> }
>
>
>
> template <class charT, class traits>
> inline std::basic_ostream<charT,traits>&
> operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
> {
> os << ec.category().name() << ':' << ec.value();
> return os;
> }
>
> inline std::size_t hash_value( const error_code & ec )
> {
> return static_cast<std::size_t>(ec.value())
> + reinterpret_cast<std::size_t>(&ec.category());
> }
>
>
>
> namespace errc
> {
>
> inline error_code make_error_code( errc_t e ) noexcept
> { return error_code( e, generic_category() ); }
>
>
> inline error_condition make_error_condition( errc_t e ) noexcept
> { return error_condition( e, generic_category() ); }
> }
>
>
>
> error_condition error_category::default_error_condition( int ev ) const
> noexcept
> {
> return error_condition( ev, *this );
> }
>
> bool error_category::equivalent( int code,
> const error_condition & condition ) const noexcept
> {
> return default_error_condition( code ) == condition;
> }
>
> bool error_category::equivalent( const error_code & code,
> int condition ) const noexcept
> {
> return *this == code.category() && code.value() == condition;
> }
>
>
>
> inline std::error_condition error_category::std_category::default_error_condition(
> int ev ) const noexcept
> {
> return pc_->default_error_condition( ev );
> }
>
> inline bool error_category::std_category::equivalent( int code,
> const std::error_condition & condition ) const noexcept
> {
> if( condition.category() == *this )
> {
> boost::system::error_condition bn( condition.value(), *pc_ );
> return pc_->equivalent( code, bn );
> }
> else if( condition.category() == std::generic_category()
> || condition.category() == boost::system::generic_category() )
> {
> boost::system::error_condition bn( condition.value(),
> boost::system::generic_category() );
>
> return pc_->equivalent( code, bn );
> }
>
> else if( std_category const* pc2 = dynamic_cast< std_category const* >(
> &condition.category() ) )
> {
> boost::system::error_condition bn( condition.value(), *pc2->pc_ );
> return pc_->equivalent( code, bn );
> }
>
> else
> {
> return default_error_condition( code ) == condition;
> }
> }
>
> inline bool error_category::std_category::equivalent( const std::error_code & code,
> int condition ) const noexcept
> {
> if( code.category() == *this )
> {
> boost::system::error_code bc( code.value(), *pc_ );
> return pc_->equivalent( bc, condition );
> }
> else if( code.category() == std::generic_category()
> || code.category() == boost::system::generic_category() )
> {
> boost::system::error_code bc( code.value(),
> boost::system::generic_category() );
>
> return pc_->equivalent( bc, condition );
> }
>
> else if( std_category const* pc2 = dynamic_cast< std_category const* >(
> &code.category() ) )
> {
> boost::system::error_code bc( code.value(), *pc2->pc_ );
> return pc_->equivalent( bc, condition );
> }
>
> else if( *pc_ == boost::system::generic_category() )
> {
> return std::generic_category().equivalent( code, condition );
> }
> else
> {
> return false;
> }
> }
>
>
>
> }
>}
>
># 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
># 737 "/usr/include/boost/system/error_code.hpp" 2 3 4
># 36 "/usr/local/include/nghttp2/asio_http2.h" 2 3
># 1 "/usr/include/boost/asio.hpp" 1 3 4
># 20 "/usr/include/boost/asio.hpp" 3 4
># 1 "/usr/include/boost/asio/associated_allocator.hpp" 1 3 4
># 18 "/usr/include/boost/asio/associated_allocator.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/config.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/config.hpp" 3 4
># 1 "/usr/include/boost/version.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/config.hpp" 2 3 4
># 951 "/usr/include/boost/asio/detail/config.hpp" 3 4
># 1 "/usr/include/linux/version.h" 1 3 4
># 952 "/usr/include/boost/asio/detail/config.hpp" 2 3 4
># 19 "/usr/include/boost/asio/associated_allocator.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/type_traits.hpp" 1 3 4
># 39 "/usr/include/boost/asio/detail/type_traits.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>using std::add_const;
>using std::conditional;
>using std::decay;
>using std::enable_if;
>using std::false_type;
>using std::integral_constant;
>using std::is_base_of;
>using std::is_class;
>using std::is_const;
>using std::is_convertible;
>using std::is_function;
>using std::is_same;
>using std::remove_pointer;
>using std::remove_reference;
>using std::result_of;
>using std::true_type;
># 79 "/usr/include/boost/asio/detail/type_traits.hpp" 3 4
>}
>}
># 21 "/usr/include/boost/asio/associated_allocator.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/associated_allocator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename>
>struct associated_allocator_check
>{
> typedef void type;
>};
>
>template <typename T, typename E, typename = void>
>struct associated_allocator_impl
>{
> typedef E type;
>
> static type get(const T&, const E& e) noexcept
> {
> return e;
> }
>};
>
>template <typename T, typename E>
>struct associated_allocator_impl<T, E,
> typename associated_allocator_check<typename T::allocator_type>::type>
>{
> typedef typename T::allocator_type type;
>
> static type get(const T& t, const E&) noexcept
> {
> return t.get_allocator();
> }
>};
>
>}
># 78 "/usr/include/boost/asio/associated_allocator.hpp" 3 4
>template <typename T, typename Allocator = std::allocator<void> >
>struct associated_allocator
>{
>
>
>
>
>
> typedef typename detail::associated_allocator_impl<T, Allocator>::type type;
>
>
>
>
> static type get(const T& t,
> const Allocator& a = Allocator()) noexcept
> {
> return detail::associated_allocator_impl<T, Allocator>::get(t, a);
> }
>};
>
>
>
>
>
>template <typename T>
>inline typename associated_allocator<T>::type
>get_associated_allocator(const T& t) noexcept
>{
> return associated_allocator<T>::get(t);
>}
>
>
>
>
>
>template <typename T, typename Allocator>
>inline typename associated_allocator<T, Allocator>::type
>get_associated_allocator(const T& t, const Allocator& a) noexcept
>{
> return associated_allocator<T, Allocator>::get(t, a);
>}
>
>
>
>template <typename T, typename Allocator = std::allocator<void> >
>using associated_allocator_t
> = typename associated_allocator<T, Allocator>::type;
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 132 "/usr/include/boost/asio/associated_allocator.hpp" 2 3 4
># 21 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/associated_executor.hpp" 1 3 4
># 20 "/usr/include/boost/asio/associated_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/is_executor.hpp" 1 3 4
># 19 "/usr/include/boost/asio/is_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/is_executor.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/is_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/is_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct executor_memfns_base
>{
> void context();
> void on_work_started();
> void on_work_finished();
> void dispatch();
> void post();
> void defer();
>};
>
>template <typename T>
>struct executor_memfns_derived
> : T, executor_memfns_base
>{
>};
>
>template <typename T, T>
>struct executor_memfns_check
>{
>};
>
>template <typename>
>char (&context_memfn_helper(...))[2];
>
>template <typename T>
>char context_memfn_helper(
> executor_memfns_check<
> void (executor_memfns_base::*)(),
> &executor_memfns_derived<T>::context>*);
>
>template <typename>
>char (&on_work_started_memfn_helper(...))[2];
>
>template <typename T>
>char on_work_started_memfn_helper(
> executor_memfns_check<
> void (executor_memfns_base::*)(),
> &executor_memfns_derived<T>::on_work_started>*);
>
>template <typename>
>char (&on_work_finished_memfn_helper(...))[2];
>
>template <typename T>
>char on_work_finished_memfn_helper(
> executor_memfns_check<
> void (executor_memfns_base::*)(),
> &executor_memfns_derived<T>::on_work_finished>*);
>
>template <typename>
>char (&dispatch_memfn_helper(...))[2];
>
>template <typename T>
>char dispatch_memfn_helper(
> executor_memfns_check<
> void (executor_memfns_base::*)(),
> &executor_memfns_derived<T>::dispatch>*);
>
>template <typename>
>char (&post_memfn_helper(...))[2];
>
>template <typename T>
>char post_memfn_helper(
> executor_memfns_check<
> void (executor_memfns_base::*)(),
> &executor_memfns_derived<T>::post>*);
>
>template <typename>
>char (&defer_memfn_helper(...))[2];
>
>template <typename T>
>char defer_memfn_helper(
> executor_memfns_check<
> void (executor_memfns_base::*)(),
> &executor_memfns_derived<T>::defer>*);
>
>template <typename T>
>struct is_executor_class
> : integral_constant<bool,
> sizeof(context_memfn_helper<T>(0)) != 1 &&
> sizeof(on_work_started_memfn_helper<T>(0)) != 1 &&
> sizeof(on_work_finished_memfn_helper<T>(0)) != 1 &&
> sizeof(dispatch_memfn_helper<T>(0)) != 1 &&
> sizeof(post_memfn_helper<T>(0)) != 1 &&
> sizeof(defer_memfn_helper<T>(0)) != 1>
>{
>};
>
>template <typename T>
>struct is_executor
> : conditional<is_class<T>::value,
> is_executor_class<T>,
> false_type>::type
>{
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 127 "/usr/include/boost/asio/detail/is_executor.hpp" 2 3 4
># 20 "/usr/include/boost/asio/is_executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/is_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 33 "/usr/include/boost/asio/is_executor.hpp" 3 4
>template <typename T>
>struct is_executor
>
>
>
> : boost::asio::detail::is_executor<T>
>
>{
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 47 "/usr/include/boost/asio/is_executor.hpp" 2 3 4
># 21 "/usr/include/boost/asio/associated_executor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/system_executor.hpp" 1 3 4
># 20 "/usr/include/boost/asio/system_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/system_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class system_context;
># 34 "/usr/include/boost/asio/system_executor.hpp" 3 4
>class system_executor
>{
>public:
>
> system_context& context() const noexcept;
>
>
>
>
>
> void on_work_started() const noexcept
> {
> }
>
>
>
>
>
> void on_work_finished() const noexcept
> {
> }
># 68 "/usr/include/boost/asio/system_executor.hpp" 3 4
> template <typename Function, typename Allocator>
> void dispatch(Function&& f, const Allocator& a) const;
># 84 "/usr/include/boost/asio/system_executor.hpp" 3 4
> template <typename Function, typename Allocator>
> void post(Function&& f, const Allocator& a) const;
># 100 "/usr/include/boost/asio/system_executor.hpp" 3 4
> template <typename Function, typename Allocator>
> void defer(Function&& f, const Allocator& a) const;
>
>
>
>
>
> friend bool operator==(const system_executor&,
> const system_executor&) noexcept
> {
> return true;
> }
>
>
>
>
>
> friend bool operator!=(const system_executor&,
> const system_executor&) noexcept
> {
> return false;
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 128 "/usr/include/boost/asio/system_executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/system_executor.hpp" 1 3 4
># 18 "/usr/include/boost/asio/impl/system_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/executor_op.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/executor_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/fenced_block.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/std_fenced_block.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/std_fenced_block.hpp" 3 4
># 1 "/usr/include/c++/8/atomic" 1 3 4
># 35 "/usr/include/c++/8/atomic" 3 4
> 
># 36 "/usr/include/c++/8/atomic" 3
># 44 "/usr/include/c++/8/atomic" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/include/c++/8/atomic" 3
> template<typename _Tp>
> struct atomic;
>
>
>
> template<>
> struct atomic<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); }
> };
>
>
>
>
>
>
>
> template<typename _Tp>
> struct atomic
> {
> private:
>
> static constexpr int _S_min_alignment
> = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
> ? 0 : sizeof(_Tp);
>
> static constexpr int _S_alignment
> = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
>
> alignas(_S_alignment) _Tp _M_i;
>
> static_assert(__is_trivially_copyable(_Tp),
> "std::atomic requires a trivially copyable type");
>
> static_assert(sizeof(_Tp) > 0,
> "Incomplete or zero-sized types are not supported");
>
> public:
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
>
> operator _Tp() const noexcept
> { return load(); }
>
> operator _Tp() const volatile noexcept
> { return load(); }
>
> _Tp
> operator=(_Tp __i) noexcept
> { store(__i); return __i; }
>
> _Tp
> operator=(_Tp __i) volatile noexcept
> { store(__i); return __i; }
>
> bool
> is_lock_free() const noexcept
> {
>
> return __atomic_is_lock_free(sizeof(_M_i),
> reinterpret_cast<void *>(-__alignof(_M_i)));
> }
>
> bool
> is_lock_free() const volatile noexcept
> {
>
> return __atomic_is_lock_free(sizeof(_M_i),
> reinterpret_cast<void *>(-__alignof(_M_i)));
> }
>
>
> static constexpr bool is_always_lock_free
> = __atomic_always_lock_free(sizeof(_M_i), 0);
>
>
> void
> store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
> { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), __m); }
>
> void
> store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
> { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), __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, __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, __m);
> return *__ptr;
> }
>
> _Tp
> exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
> {
> alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
> _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
> __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
> __ptr, __m);
> return *__ptr;
> }
>
> _Tp
> exchange(_Tp __i,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
> _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
> __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
> __ptr, __m);
> return *__ptr;
> }
>
> bool
> compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) noexcept
> {
> return __atomic_compare_exchange(std::__addressof(_M_i),
> std::__addressof(__e),
> std::__addressof(__i),
> true, __s, __f);
> }
>
> bool
> compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) volatile noexcept
> {
> return __atomic_compare_exchange(std::__addressof(_M_i),
> std::__addressof(__e),
> std::__addressof(__i),
> true, __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_compare_exchange(std::__addressof(_M_i),
> std::__addressof(__e),
> std::__addressof(__i),
> false, __s, __f);
> }
>
> bool
> compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
> memory_order __f) volatile noexcept
> {
> return __atomic_compare_exchange(std::__addressof(_M_i),
> std::__addressof(__e),
> std::__addressof(__i),
> false, __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)); }
> };
>
>
>
> template<typename _Tp>
> struct atomic<_Tp*>
> {
> 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
> { return _M_b++; }
>
> __pointer_type
> operator++(int) volatile noexcept
> { return _M_b++; }
>
> __pointer_type
> operator--(int) noexcept
> { return _M_b--; }
>
> __pointer_type
> operator--(int) volatile noexcept
> { return _M_b--; }
>
> __pointer_type
> operator++() noexcept
> { return ++_M_b; }
>
> __pointer_type
> operator++() volatile noexcept
> { return ++_M_b; }
>
> __pointer_type
> operator--() noexcept
> { return --_M_b; }
>
> __pointer_type
> operator--() volatile noexcept
> { return --_M_b; }
>
> __pointer_type
> operator+=(ptrdiff_t __d) noexcept
> { return _M_b.operator+=(__d); }
>
> __pointer_type
> operator+=(ptrdiff_t __d) volatile noexcept
> { return _M_b.operator+=(__d); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) noexcept
> { return _M_b.operator-=(__d); }
>
> __pointer_type
> operator-=(ptrdiff_t __d) volatile noexcept
> { return _M_b.operator-=(__d); }
>
> bool
> is_lock_free() const noexcept
> { return _M_b.is_lock_free(); }
>
> bool
> is_lock_free() const volatile noexcept
> { return _M_b.is_lock_free(); }
>
>
> static constexpr bool is_always_lock_free = 2 == 2;
>
>
> void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.store(__p, __m); }
>
> void
> store(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.store(__p, __m); }
>
> __pointer_type
> load(memory_order __m = memory_order_seq_cst) const noexcept
> { return _M_b.load(__m); }
>
> __pointer_type
> load(memory_order __m = memory_order_seq_cst) const volatile noexcept
> { return _M_b.load(__m); }
>
> __pointer_type
> exchange(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.exchange(__p, __m); }
>
> __pointer_type
> exchange(__pointer_type __p,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.exchange(__p, __m); }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1, memory_order __m2) noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return compare_exchange_weak(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return compare_exchange_weak(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1, memory_order __m2) noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m1,
> memory_order __m2) volatile noexcept
> { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) noexcept
> {
> return _M_b.compare_exchange_strong(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> bool
> compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> {
> return _M_b.compare_exchange_strong(__p1, __p2, __m,
> __cmpexch_failure_order(__m));
> }
>
> __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.fetch_add(__d, __m); }
>
> __pointer_type
> fetch_add(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { return _M_b.fetch_add(__d, __m); }
>
> __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) noexcept
> { return _M_b.fetch_sub(__d, __m); }
>
> __pointer_type
> fetch_sub(ptrdiff_t __d,
> memory_order __m = memory_order_seq_cst) volatile noexcept
> { 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<char16_t> : __atomic_base<char16_t>
> {
> typedef char16_t __integral_type;
> typedef __atomic_base<char16_t> __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
>
>
> static constexpr bool is_always_lock_free = 2 == 2;
>
> };
>
>
> template<>
> struct atomic<char32_t> : __atomic_base<char32_t>
> {
> typedef char32_t __integral_type;
> typedef __atomic_base<char32_t> __base_type;
>
> atomic() noexcept = default;
> ~atomic() noexcept = default;
> atomic(const atomic&) = delete;
> atomic& operator=(const atomic&) = delete;
> atomic& operator=(const atomic&) volatile = delete;
>
> constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
>
> using __base_type::operator __integral_type;
> using __base_type::operator=;
>
>
> static constexpr bool is_always_lock_free = 2 == 2;
>
> };
>
>
>
> typedef atomic<bool> atomic_bool;
>
>
> typedef atomic<char> atomic_char;
>
>
> typedef atomic<signed char> atomic_schar;
>
>
> typedef atomic<unsigned char> atomic_uchar;
>
>
> typedef atomic<short> atomic_short;
>
>
> typedef atomic<unsigned short> atomic_ushort;
>
>
> typedef atomic<int> atomic_int;
>
>
> typedef atomic<unsigned int> atomic_uint;
>
>
> typedef atomic<long> atomic_long;
>
>
> typedef atomic<unsigned long> atomic_ulong;
>
>
> typedef atomic<long long> atomic_llong;
>
>
> typedef atomic<unsigned long long> atomic_ullong;
>
>
> typedef atomic<wchar_t> atomic_wchar_t;
>
>
> typedef atomic<char16_t> atomic_char16_t;
>
>
> typedef atomic<char32_t> atomic_char32_t;
>
>
>
>
>
>
> typedef atomic<int8_t> atomic_int8_t;
>
>
> typedef atomic<uint8_t> atomic_uint8_t;
>
>
> typedef atomic<int16_t> atomic_int16_t;
>
>
> typedef atomic<uint16_t> atomic_uint16_t;
>
>
> typedef atomic<int32_t> atomic_int32_t;
>
>
> typedef atomic<uint32_t> atomic_uint32_t;
>
>
> typedef atomic<int64_t> atomic_int64_t;
>
>
> typedef atomic<uint64_t> atomic_uint64_t;
>
>
>
> typedef atomic<int_least8_t> atomic_int_least8_t;
>
>
> typedef atomic<uint_least8_t> atomic_uint_least8_t;
>
>
> typedef atomic<int_least16_t> atomic_int_least16_t;
>
>
> typedef atomic<uint_least16_t> atomic_uint_least16_t;
>
>
> typedef atomic<int_least32_t> atomic_int_least32_t;
>
>
> typedef atomic<uint_least32_t> atomic_uint_least32_t;
>
>
> typedef atomic<int_least64_t> atomic_int_least64_t;
>
>
> typedef atomic<uint_least64_t> atomic_uint_least64_t;
>
>
>
> typedef atomic<int_fast8_t> atomic_int_fast8_t;
>
>
> typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
>
>
> typedef atomic<int_fast16_t> atomic_int_fast16_t;
>
>
> typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
>
>
> typedef atomic<int_fast32_t> atomic_int_fast32_t;
>
>
> typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
>
>
> typedef atomic<int_fast64_t> atomic_int_fast64_t;
>
>
> typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
>
>
>
>
> typedef atomic<intptr_t> atomic_intptr_t;
>
>
> typedef atomic<uintptr_t> atomic_uintptr_t;
>
>
> typedef atomic<size_t> atomic_size_t;
>
>
> typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
>
>
>
> typedef atomic<intmax_t> atomic_intmax_t;
>
>
> typedef atomic<uintmax_t> atomic_uintmax_t;
>
>
>
> inline bool
> atomic_flag_test_and_set_explicit(atomic_flag* __a,
> memory_order __m) noexcept
> { return __a->test_and_set(__m); }
>
> inline bool
> atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
> memory_order __m) noexcept
> { return __a->test_and_set(__m); }
>
> inline void
> atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
> { __a->clear(__m); }
>
> inline void
> atomic_flag_clear_explicit(volatile atomic_flag* __a,
> memory_order __m) noexcept
> { __a->clear(__m); }
>
> inline bool
> atomic_flag_test_and_set(atomic_flag* __a) noexcept
> { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
>
> inline bool
> atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
> { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
>
> inline void
> atomic_flag_clear(atomic_flag* __a) noexcept
> { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
>
> inline void
> atomic_flag_clear(volatile atomic_flag* __a) noexcept
> { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
>
>
>
> template<typename _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, _ITp __i) noexcept
> { __a->store(__i, memory_order_relaxed); }
>
> template<typename _ITp>
> inline void
> atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
> { __a->store(__i, memory_order_relaxed); }
>
> template<typename _ITp>
> inline void
> atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { __a->store(__i, __m); }
>
> template<typename _ITp>
> inline void
> atomic_store_explicit(volatile atomic<_ITp>* __a, _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, _ITp __i,
> memory_order __m) noexcept
> { return __a->exchange(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->exchange(__i, __m); }
>
> template<typename _ITp>
> inline bool
> atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
> _ITp* __i1, _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,
> _ITp* __i1, _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,
> _ITp* __i1, _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,
> _ITp* __i1, _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, _ITp __i) noexcept
> { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline void
> atomic_store(volatile atomic<_ITp>* __a, _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, _ITp __i) noexcept
> { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_exchange(volatile atomic<_ITp>* __a, _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,
> _ITp* __i1, _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,
> _ITp* __i1, _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,
> _ITp* __i1, _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,
> _ITp* __i1, _ITp __i2) noexcept
> {
> return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
> memory_order_seq_cst,
> memory_order_seq_cst);
> }
>
>
>
>
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_add(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_add(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_sub(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _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, _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, _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, _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, _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, _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, _ITp __i,
> memory_order __m) noexcept
> { return __a->fetch_xor(__i, __m); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
> { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
>
> template<typename _ITp>
> inline _ITp
> atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _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, _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, _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, _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, _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, _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, _ITp __i) noexcept
> { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
>
>
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
> memory_order __m) noexcept
> { return __a->fetch_add(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
> memory_order __m) noexcept
> { return __a->fetch_add(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_add(__d); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_add(__d); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
> ptrdiff_t __d, memory_order __m) noexcept
> { return __a->fetch_sub(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
> memory_order __m) noexcept
> { return __a->fetch_sub(__d, __m); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_sub(__d); }
>
> template<typename _ITp>
> inline _ITp*
> atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
> { return __a->fetch_sub(__d); }
>
>
>
>}
># 23 "/usr/include/boost/asio/detail/std_fenced_block.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/noncopyable.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/noncopyable.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/noncopyable.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class noncopyable
>{
>protected:
> noncopyable() {}
> ~noncopyable() {}
>private:
> noncopyable(const noncopyable&);
> const noncopyable& operator=(const noncopyable&);
>};
>
>}
>
>using boost::asio::detail::noncopyable;
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 44 "/usr/include/boost/asio/detail/noncopyable.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/std_fenced_block.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/std_fenced_block.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class std_fenced_block
> : private noncopyable
>{
>public:
> enum half_t { half };
> enum full_t { full };
>
>
> explicit std_fenced_block(half_t)
> {
> }
>
>
> explicit std_fenced_block(full_t)
> {
> std::atomic_thread_fence(std::memory_order_acquire);
> }
>
>
> ~std_fenced_block()
> {
> std::atomic_thread_fence(std::memory_order_release);
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 61 "/usr/include/boost/asio/detail/std_fenced_block.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/fenced_block.hpp" 2 3 4
># 47 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>typedef std_fenced_block fenced_block;
># 78 "/usr/include/boost/asio/detail/fenced_block.hpp" 3 4
>}
>}
>}
># 20 "/usr/include/boost/asio/detail/executor_op.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/memory.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/memory.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using std::shared_ptr;
>using std::weak_ptr;
>
>
>
>
>
>
>using std::addressof;
>
>
>
>
>}
>
>
>using std::allocator_arg_t;
># 69 "/usr/include/boost/asio/detail/memory.hpp" 3 4
>}
>}
># 20 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/recycling_allocator.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/recycling_allocator.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/thread_context.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/thread_context.hpp" 3 4
># 1 "/usr/include/c++/8/climits" 1 3 4
># 39 "/usr/include/c++/8/climits" 3 4
> 
># 40 "/usr/include/c++/8/climits" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 1 3 4
># 34 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 1 3 4
># 194 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 26 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/libc-header-start.h" 1 3 4
># 27 "/usr/include/limits.h" 2 3 4
># 183 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 160 "/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
># 161 "/usr/include/bits/posix1_lim.h" 2 3 4
># 184 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 188 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 64 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/uio_lim.h" 1 3 4
># 65 "/usr/include/bits/xopen_lim.h" 2 3 4
># 192 "/usr/include/limits.h" 2 3 4
># 195 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h" 2 3 4
># 35 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 2 3 4
># 43 "/usr/include/c++/8/climits" 2 3
># 19 "/usr/include/boost/asio/detail/thread_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/call_stack.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/call_stack.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/tss_ptr.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/tss_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class keyword_tss_ptr
> : private noncopyable
>{
>public:
>
> keyword_tss_ptr()
> {
> }
>
>
> ~keyword_tss_ptr()
> {
> }
>
>
> operator T*() const
> {
> return value_;
> }
>
>
> void operator=(T* value)
> {
> value_ = value;
> }
>
>private:
> static __thread T* value_;
>};
>
>template <typename T>
>__thread T* keyword_tss_ptr<T>::value_;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 69 "/usr/include/boost/asio/detail/keyword_tss_ptr.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/tss_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 33 "/usr/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class tss_ptr
>
>
>
> : public keyword_tss_ptr<T>
>
>
>
>
>
>{
>public:
> void operator=(T* value)
> {
>
>
>
> keyword_tss_ptr<T>::operator=(value);
>
>
>
>
>
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 70 "/usr/include/boost/asio/detail/tss_ptr.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/call_stack.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/call_stack.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>template <typename Key, typename Value = unsigned char>
>class call_stack
>{
>public:
>
> class context
> : private noncopyable
> {
> public:
>
> explicit context(Key* k)
> : key_(k),
> next_(call_stack<Key, Value>::top_)
> {
> value_ = reinterpret_cast<unsigned char*>(this);
> call_stack<Key, Value>::top_ = this;
> }
>
>
> context(Key* k, Value& v)
> : key_(k),
> value_(&v),
> next_(call_stack<Key, Value>::top_)
> {
> call_stack<Key, Value>::top_ = this;
> }
>
>
> ~context()
> {
> call_stack<Key, Value>::top_ = next_;
> }
>
>
> Value* next_by_key() const
> {
> context* elem = next_;
> while (elem)
> {
> if (elem->key_ == key_)
> return elem->value_;
> elem = elem->next_;
> }
> return 0;
> }
>
> private:
> friend class call_stack<Key, Value>;
>
>
> Key* key_;
>
>
> Value* value_;
>
>
> context* next_;
> };
>
> friend class context;
>
>
>
> static Value* contains(Key* k)
> {
> context* elem = top_;
> while (elem)
> {
> if (elem->key_ == k)
> return elem->value_;
> elem = elem->next_;
> }
> return 0;
> }
>
>
> static Value* top()
> {
> context* elem = top_;
> return elem ? elem->value_ : 0;
> }
>
>private:
>
> static tss_ptr<context> top_;
>};
>
>template <typename Key, typename Value>
>tss_ptr<typename call_stack<Key, Value>::context>
>call_stack<Key, Value>::top_;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 126 "/usr/include/boost/asio/detail/call_stack.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/thread_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/thread_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class thread_info_base;
>
>
>class thread_context
>{
>public:
>
> typedef call_stack<thread_context, thread_info_base> thread_call_stack;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 43 "/usr/include/boost/asio/detail/thread_context.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/thread_info_base.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/thread_info_base.hpp" 3 4
># 1 "/usr/include/c++/8/climits" 1 3 4
># 39 "/usr/include/c++/8/climits" 3 4
> 
># 40 "/usr/include/c++/8/climits" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 1 3 4
># 43 "/usr/include/c++/8/climits" 2 3
># 19 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class thread_info_base
> : private noncopyable
>{
>public:
> thread_info_base()
> : reusable_memory_(0)
> {
> }
>
> ~thread_info_base()
> {
> if (reusable_memory_)
> ::operator delete(reusable_memory_);
> }
>
> static void* allocate(thread_info_base* this_thread, std::size_t size)
> {
> std::size_t chunks = (size + chunk_size - 1) / chunk_size;
>
> if (this_thread && this_thread->reusable_memory_)
> {
> void* const pointer = this_thread->reusable_memory_;
> this_thread->reusable_memory_ = 0;
>
> unsigned char* const mem = static_cast<unsigned char*>(pointer);
> if (static_cast<std::size_t>(mem[0]) >= chunks)
> {
> mem[size] = mem[0];
> return pointer;
> }
>
> ::operator delete(pointer);
> }
>
> void* const pointer = ::operator new(chunks * chunk_size + 1);
> unsigned char* const mem = static_cast<unsigned char*>(pointer);
> mem[size] = (chunks <= (0x7f * 2 + 1)) ? static_cast<unsigned char>(chunks) : 0;
> return pointer;
> }
>
> static void deallocate(thread_info_base* this_thread,
> void* pointer, std::size_t size)
> {
> if (size <= chunk_size * (0x7f * 2 + 1))
> {
> if (this_thread && this_thread->reusable_memory_ == 0)
> {
> unsigned char* const mem = static_cast<unsigned char*>(pointer);
> mem[0] = mem[size];
> this_thread->reusable_memory_ = pointer;
> return;
> }
> }
>
> ::operator delete(pointer);
> }
>
>private:
> enum { chunk_size = 4 };
> void* reusable_memory_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 95 "/usr/include/boost/asio/detail/thread_info_base.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class recycling_allocator
>{
>public:
> typedef T value_type;
>
> template <typename U>
> struct rebind
> {
> typedef recycling_allocator other;
> };
>
> recycling_allocator()
> {
> }
>
> template <typename U>
> recycling_allocator(const recycling_allocator&)
> {
> }
>
> T* allocate(std::size_t n)
> {
> typedef thread_context::thread_call_stack call_stack;
> void* p = thread_info_base::allocate(call_stack::top(), sizeof(T) * n);
> return static_cast<T*>(p);
> }
>
> void deallocate(T* p, std::size_t n)
> {
> typedef thread_context::thread_call_stack call_stack;
> thread_info_base::deallocate(call_stack::top(), p, sizeof(T) * n);
> }
>};
>
>template <>
>class recycling_allocator<void>
>{
>public:
> typedef void value_type;
>
> template <typename U>
> struct rebind
> {
> typedef recycling_allocator other;
> };
>
> recycling_allocator()
> {
> }
>
> template <typename U>
> recycling_allocator(const recycling_allocator&)
> {
> }
>};
>
>template <typename Allocator>
>struct get_recycling_allocator
>{
> typedef Allocator type;
> static type get(const Allocator& a) { return a; }
>};
>
>template <typename T>
>struct get_recycling_allocator<std::allocator<T> >
>{
> typedef recycling_allocator<T> type;
> static type get(const std::allocator<T>&) { return type(); }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 105 "/usr/include/boost/asio/detail/recycling_allocator.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/handler_alloc_hook.hpp" 1 3 4
># 21 "/usr/include/boost/asio/handler_alloc_hook.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 58 "/usr/include/boost/asio/handler_alloc_hook.hpp" 3 4
>inline void* asio_handler_allocate(
> std::size_t size, ...);
># 71 "/usr/include/boost/asio/handler_alloc_hook.hpp" 3 4
>inline void asio_handler_deallocate(
> void* pointer, std::size_t size, ...);
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 78 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 1 3 4
># 21 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 3 4
># 1 "/usr/include/boost/asio/handler_alloc_hook.hpp" 1 3 4
># 22 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>void* asio_handler_allocate(std::size_t size, ...)
>{
>
> return detail::thread_info_base::allocate(
> detail::thread_context::thread_call_stack::top(), size);
>
>
>
>}
>
>void asio_handler_deallocate(void* pointer, std::size_t size, ...)
>{
>
> detail::thread_info_base::deallocate(
> detail::thread_context::thread_call_stack::top(), pointer, size);
>
>
>
>
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 53 "/usr/include/boost/asio/impl/handler_alloc_hook.ipp" 2 3 4
># 81 "/usr/include/boost/asio/handler_alloc_hook.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
>
>
>
>
>namespace boost_asio_handler_alloc_helpers {
>
>template <typename Handler>
>inline void* allocate(std::size_t s, Handler& h)
>{
>
>
>
> using boost::asio::asio_handler_allocate;
> return asio_handler_allocate(s, boost::asio::detail::addressof(h));
>
>}
>
>template <typename Handler>
>inline void deallocate(void* p, std::size_t s, Handler& h)
>{
>
>
>
> using boost::asio::asio_handler_deallocate;
> asio_handler_deallocate(p, s, boost::asio::detail::addressof(h));
>
>}
>
>}
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler, typename T>
>class hook_allocator
>{
>public:
> typedef T value_type;
>
> template <typename U>
> struct rebind
> {
> typedef hook_allocator<Handler, U> other;
> };
>
> explicit hook_allocator(Handler& h)
> : handler_(h)
> {
> }
>
> template <typename U>
> hook_allocator(const hook_allocator<Handler, U>& a)
> : handler_(a.handler_)
> {
> }
>
> T* allocate(std::size_t n)
> {
> return static_cast<T*>(
> boost_asio_handler_alloc_helpers::allocate(sizeof(T) * n, handler_));
> }
>
> void deallocate(T* p, std::size_t n)
> {
> boost_asio_handler_alloc_helpers::deallocate(p, sizeof(T) * n, handler_);
> }
>
>
> Handler& handler_;
>};
>
>template <typename Handler>
>class hook_allocator<Handler, void>
>{
>public:
> typedef void value_type;
>
> template <typename U>
> struct rebind
> {
> typedef hook_allocator<Handler, U> other;
> };
>
> explicit hook_allocator(Handler& h)
> : handler_(h)
> {
> }
>
> template <typename U>
> hook_allocator(const hook_allocator<Handler, U>& a)
> : handler_(a.handler_)
> {
> }
>
>
> Handler& handler_;
>};
>
>template <typename Handler, typename Allocator>
>struct get_hook_allocator
>{
> typedef Allocator type;
>
> static type get(Handler&, const Allocator& a)
> {
> return a;
> }
>};
>
>template <typename Handler, typename T>
>struct get_hook_allocator<Handler, std::allocator<T> >
>{
> typedef hook_allocator<Handler, T> type;
>
> static type get(Handler& handler, const std::allocator<T>&)
> {
> return type(handler);
> }
>};
>
>}
>}
>}
># 235 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 236 "/usr/include/boost/asio/detail/handler_alloc_helpers.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/executor_op.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/handler_invoke_hook.hpp" 1 3 4
># 20 "/usr/include/boost/asio/handler_invoke_hook.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/handler_invoke_hook.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 66 "/usr/include/boost/asio/handler_invoke_hook.hpp" 3 4
>template <typename Function>
>inline void asio_handler_invoke(Function& function, ...)
>{
> function();
>}
>
>
>template <typename Function>
>inline void asio_handler_invoke(const Function& function, ...)
>{
> Function tmp(function);
> tmp();
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 86 "/usr/include/boost/asio/handler_invoke_hook.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
>
>
>
>
>namespace boost_asio_handler_invoke_helpers {
>
>template <typename Function, typename Context>
>inline void invoke(Function& function, Context& context)
>{
>
>
>
>
> using boost::asio::asio_handler_invoke;
> asio_handler_invoke(function, boost::asio::detail::addressof(context));
>
>}
>
>template <typename Function, typename Context>
>inline void invoke(const Function& function, Context& context)
>{
>
>
>
>
> using boost::asio::asio_handler_invoke;
> asio_handler_invoke(function, boost::asio::detail::addressof(context));
>
>}
>
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 56 "/usr/include/boost/asio/detail/handler_invoke_helpers.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/executor_op.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/scheduler_operation.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/scheduler_operation.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_tracking.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/handler_tracking.hpp" 3 4
>namespace boost {
>namespace asio {
>
>class execution_context;
>
>}
>}
># 37 "/usr/include/boost/asio/detail/handler_tracking.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 38 "/usr/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
># 232 "/usr/include/boost/asio/detail/handler_tracking.hpp" 3 4
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 237 "/usr/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/handler_tracking.ipp" 1 3 4
># 240 "/usr/include/boost/asio/detail/handler_tracking.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/op_queue.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/op_queue.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/op_queue.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Operation>
>class op_queue;
>
>class op_queue_access
>{
>public:
> template <typename Operation>
> static Operation* next(Operation* o)
> {
> return static_cast<Operation*>(o->next_);
> }
>
> template <typename Operation1, typename Operation2>
> static void next(Operation1*& o1, Operation2* o2)
> {
> o1->next_ = o2;
> }
>
> template <typename Operation>
> static void destroy(Operation* o)
> {
> o->destroy();
> }
>
> template <typename Operation>
> static Operation*& front(op_queue<Operation>& q)
> {
> return q.front_;
> }
>
> template <typename Operation>
> static Operation*& back(op_queue<Operation>& q)
> {
> return q.back_;
> }
>};
>
>template <typename Operation>
>class op_queue
> : private noncopyable
>{
>public:
>
> op_queue()
> : front_(0),
> back_(0)
> {
> }
>
>
> ~op_queue()
> {
> while (Operation* op = front_)
> {
> pop();
> op_queue_access::destroy(op);
> }
> }
>
>
> Operation* front()
> {
> return front_;
> }
>
>
> void pop()
> {
> if (front_)
> {
> Operation* tmp = front_;
> front_ = op_queue_access::next(front_);
> if (front_ == 0)
> back_ = 0;
> op_queue_access::next(tmp, static_cast<Operation*>(0));
> }
> }
>
>
> void push(Operation* h)
> {
> op_queue_access::next(h, static_cast<Operation*>(0));
> if (back_)
> {
> op_queue_access::next(back_, h);
> back_ = h;
> }
> else
> {
> front_ = back_ = h;
> }
> }
>
>
>
> template <typename OtherOperation>
> void push(op_queue<OtherOperation>& q)
> {
> if (Operation* other_front = op_queue_access::front(q))
> {
> if (back_)
> op_queue_access::next(back_, other_front);
> else
> front_ = other_front;
> back_ = op_queue_access::back(q);
> op_queue_access::front(q) = 0;
> op_queue_access::back(q) = 0;
> }
> }
>
>
> bool empty() const
> {
> return front_ == 0;
> }
>
>
> bool is_enqueued(Operation* o) const
> {
> return op_queue_access::next(o) != 0 || back_ == o;
> }
>
>private:
> friend class op_queue_access;
>
>
> Operation* front_;
>
>
> Operation* back_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 163 "/usr/include/boost/asio/detail/op_queue.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class scheduler;
>
>
>
>class scheduler_operation
>{
>public:
> typedef scheduler_operation operation_type;
>
> void complete(void* owner, const boost::system::error_code& ec,
> std::size_t bytes_transferred)
> {
> func_(owner, this, ec, bytes_transferred);
> }
>
> void destroy()
> {
> func_(0, this, boost::system::error_code(), 0);
> }
>
>protected:
> typedef void (*func_type)(void*,
> scheduler_operation*,
> const boost::system::error_code&, std::size_t);
>
> scheduler_operation(func_type func)
> : next_(0),
> func_(func),
> task_result_(0)
> {
> }
>
>
> ~scheduler_operation()
> {
> }
>
>private:
> friend class op_queue_access;
> scheduler_operation* next_;
> func_type func_;
>protected:
> friend class scheduler;
> unsigned int task_result_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 79 "/usr/include/boost/asio/detail/scheduler_operation.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/executor_op.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/executor_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler, typename Alloc,
> typename Operation = scheduler_operation>
>class executor_op : public Operation
>{
>public:
> struct ptr { const Alloc* a; void* v; executor_op* p; ~ptr() { reset(); } static executor_op* allocate(const Alloc& a) { typedef typename ::boost::asio::detail::get_recycling_allocator< Alloc>::type recycling_allocator_type; typename std::allocator_traits<recycling_allocator_type>::template rebind_alloc<executor_op> a1( ::boost::asio::detail::get_recycling_allocator<Alloc>::get(a)); return a1.allocate(1); } void reset() { if (p) { p->~executor_op(); p = 0; } if (v) { typedef typename ::boost::asio::detail::get_recycling_allocator< Alloc>::type recycling_allocator_type; typename std::allocator_traits<recycling_allocator_type>::template rebind_alloc<executor_op> a1( ::boost::asio::detail::get_recycling_allocator<Alloc>::get(*a)); a1.deallocate(static_cast<executor_op*>(v), 1); v = 0; } } };
>
> template <typename H>
> executor_op(H&& h, const Alloc& allocator)
> : Operation(&executor_op::do_complete),
> handler_(static_cast<H&&>(h)),
> allocator_(allocator)
> {
> }
>
> static void do_complete(void* owner, Operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> executor_op* o(static_cast<executor_op*>(base));
> Alloc allocator(o->allocator_);
> ptr p = { detail::addressof(allocator), o, o };
>
> (void)0;
>
>
>
>
>
>
>
> Handler handler(static_cast<Handler&&>(o->handler_));
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> boost_asio_handler_invoke_helpers::invoke(handler, handler);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
> Alloc allocator_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 85 "/usr/include/boost/asio/detail/executor_op.hpp" 2 3 4
># 19 "/usr/include/boost/asio/impl/system_executor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/global.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/global.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_global.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/posix_global.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/posix_global.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>struct posix_global_impl
>{
>
> static void do_init()
> {
> instance_.static_ptr_ = instance_.ptr_ = new T;
> }
>
>
> ~posix_global_impl()
> {
> delete static_ptr_;
> }
>
> static ::pthread_once_t init_once_;
> static T* static_ptr_;
> static posix_global_impl instance_;
> T* ptr_;
>};
>
>template <typename T>
>::pthread_once_t posix_global_impl<T>::init_once_ = 0;
>
>template <typename T>
>T* posix_global_impl<T>::static_ptr_ = 0;
>
>template <typename T>
>posix_global_impl<T> posix_global_impl<T>::instance_;
>
>template <typename T>
>T& posix_global()
>{
> int result = ::pthread_once(
> &posix_global_impl<T>::init_once_,
> &posix_global_impl<T>::do_init);
>
> if (result != 0)
> std::terminate();
>
> return *posix_global_impl<T>::instance_.ptr_;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 79 "/usr/include/boost/asio/detail/posix_global.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/global.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>inline T& global()
>{
>
>
>
>
>
> return posix_global<T>();
>
>
>
>}
>
>}
>}
>}
># 20 "/usr/include/boost/asio/impl/system_executor.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/system_context.hpp" 1 3 4
># 19 "/usr/include/boost/asio/system_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/scheduler.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/scheduler.hpp" 3 4
># 1 "/usr/include/boost/asio/execution_context.hpp" 1 3 4
># 23 "/usr/include/boost/asio/execution_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/variadic_templates.hpp" 1 3 4
># 24 "/usr/include/boost/asio/execution_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/execution_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class execution_context;
>class io_context;
>
>
>template <typename Service> Service& use_service(execution_context&);
>template <typename Service> Service& use_service(io_context&);
>template <typename Service> void add_service(execution_context&, Service*);
>template <typename Service> bool has_service(execution_context&);
>
>
>namespace detail { class service_registry; }
># 106 "/usr/include/boost/asio/execution_context.hpp" 3 4
>class execution_context
> : private noncopyable
>{
>public:
> class id;
> class service;
>
>protected:
>
> inline execution_context();
>
>
> inline ~execution_context();
># 128 "/usr/include/boost/asio/execution_context.hpp" 3 4
> inline void shutdown();
># 138 "/usr/include/boost/asio/execution_context.hpp" 3 4
> inline void destroy();
>
>public:
>
> enum fork_event
> {
>
> fork_prepare,
>
>
> fork_parent,
>
>
> fork_child
> };
># 194 "/usr/include/boost/asio/execution_context.hpp" 3 4
> inline void notify_fork(fork_event event);
># 207 "/usr/include/boost/asio/execution_context.hpp" 3 4
> template <typename Service>
> friend Service& use_service(execution_context& e);
># 224 "/usr/include/boost/asio/execution_context.hpp" 3 4
> template <typename Service>
> friend Service& use_service(io_context& ioc);
># 246 "/usr/include/boost/asio/execution_context.hpp" 3 4
> template <typename Service, typename... Args>
> friend Service& make_service(execution_context& e,
> Args&&... args);
># 284 "/usr/include/boost/asio/execution_context.hpp" 3 4
> template <typename Service>
> friend void add_service(execution_context& e, Service* svc);
># 297 "/usr/include/boost/asio/execution_context.hpp" 3 4
> template <typename Service>
> friend bool has_service(execution_context& e);
>
>private:
>
> boost::asio::detail::service_registry* service_registry_;
>};
>
>
>class execution_context::id
> : private noncopyable
>{
>public:
>
> id() {}
>};
>
>
>class execution_context::service
> : private noncopyable
>{
>public:
>
> execution_context& context();
>
>protected:
>
>
>
>
> inline service(execution_context& owner);
>
>
> inline virtual ~service();
>
>private:
>
> virtual void shutdown() = 0;
>
>
>
>
>
>
>
> inline virtual void notify_fork(
> execution_context::fork_event event);
>
> friend class boost::asio::detail::service_registry;
> struct key
> {
> key() : type_info_(0), id_(0) {}
> const std::type_info* type_info_;
> const execution_context::id* id_;
> } key_;
>
> execution_context& owner_;
> service* next_;
>};
>
>
>
>class service_already_exists
> : public std::logic_error
>{
>public:
> inline service_already_exists();
>};
>
>
>
>class invalid_service_owner
> : public std::logic_error
>{
>public:
> inline invalid_service_owner();
>};
>
>namespace detail {
>
>
>template <typename Type>
>class service_id
> : public execution_context::id
>{
>};
>
>
>template <typename Type>
>class execution_context_service_base
> : public execution_context::service
>{
>public:
> static service_id<Type> id;
>
>
> execution_context_service_base(execution_context& e)
> : execution_context::service(e)
> {
> }
>};
>
>template <typename Type>
>service_id<Type> execution_context_service_base<Type>::id;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 407 "/usr/include/boost/asio/execution_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/execution_context.hpp" 1 3 4
># 18 "/usr/include/boost/asio/impl/execution_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 1 3 4
># 53 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
># 1 "/usr/include/boost/asio/async_result.hpp" 1 3 4
># 20 "/usr/include/boost/asio/async_result.hpp" 3 4
># 1 "/usr/include/boost/asio/handler_type.hpp" 1 3 4
># 21 "/usr/include/boost/asio/handler_type.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/handler_type.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 36 "/usr/include/boost/asio/handler_type.hpp" 3 4
>template <typename CompletionToken, typename Signature, typename = void>
>struct handler_type
>{
>
> typedef typename conditional<
> is_same<CompletionToken, typename decay<CompletionToken>::type>::value,
> decay<CompletionToken>,
> handler_type<typename decay<CompletionToken>::type, Signature>
> >::type::type type;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 51 "/usr/include/boost/asio/handler_type.hpp" 2 3 4
># 21 "/usr/include/boost/asio/async_result.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/async_result.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 48 "/usr/include/boost/asio/async_result.hpp" 3 4
>template <typename CompletionToken, typename Signature = void>
>
>class async_result
>{
>public:
># 62 "/usr/include/boost/asio/async_result.hpp" 3 4
> typedef typename handler_type<CompletionToken, Signature>::type
> completion_handler_type;
>
>
>
> typedef typename async_result<completion_handler_type>::type return_type;
># 76 "/usr/include/boost/asio/async_result.hpp" 3 4
> explicit async_result(completion_handler_type& h)
>
>
>
> : legacy_result_(h)
>
> {
> (void)h;
> }
>
>
> return_type get()
> {
>
>
>
> return legacy_result_.get();
>
> }
>
>private:
> async_result(const async_result&) = delete;
> async_result& operator=(const async_result&) = delete;
>
>
>
>
> async_result<completion_handler_type> legacy_result_;
>
>};
># 114 "/usr/include/boost/asio/async_result.hpp" 3 4
>template <typename Handler>
>class async_result<Handler>
>{
>public:
>
> typedef void type;
>
>
>
>
>
>
>
> explicit async_result(Handler&)
> {
> }
>
>
> type get()
> {
> }
>};
>
>
>
>
>
>
>template <typename CompletionToken, typename Signature>
>struct async_completion
>{
>
> typedef typename boost::asio::async_result<
> typename decay<CompletionToken>::type,
> Signature>::completion_handler_type completion_handler_type;
>
>
>
>
>
>
>
> explicit async_completion(CompletionToken& token)
> : completion_handler(static_cast<typename conditional<
> is_same<CompletionToken, completion_handler_type>::value,
> completion_handler_type&, CompletionToken&&>::type>(token)),
> result(completion_handler)
> {
> }
># 179 "/usr/include/boost/asio/async_result.hpp" 3 4
> typename conditional<
> is_same<CompletionToken, completion_handler_type>::value,
> completion_handler_type&, completion_handler_type>::type completion_handler;
>
>
>
>
>
> async_result<typename decay<CompletionToken>::type, Signature> result;
>};
>
>namespace detail {
>
>template <typename CompletionToken, typename Signature>
>struct async_result_helper
> : async_result<typename decay<CompletionToken>::type, Signature>
>{
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 203 "/usr/include/boost/asio/async_result.hpp" 2 3 4
># 54 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 2 3 4
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>template <typename Handler>
>auto zero_arg_copyable_handler_test(Handler h, void*)
> -> decltype(
> sizeof(Handler(static_cast<const Handler&>(h))),
> ((h)()),
> char(0));
>
>template <typename Handler>
>char (&zero_arg_copyable_handler_test(Handler, ...))[2];
>
>template <typename Handler, typename Arg1>
>auto one_arg_handler_test(Handler h, Arg1* a1)
> -> decltype(
> sizeof(Handler(static_cast<Handler&&>(h))),
> ((h)(*a1)),
> char(0));
>
>template <typename Handler>
>char (&one_arg_handler_test(Handler h, ...))[2];
>
>template <typename Handler, typename Arg1, typename Arg2>
>auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
> -> decltype(
> sizeof(Handler(static_cast<Handler&&>(h))),
> ((h)(*a1, *a2)),
> char(0));
>
>template <typename Handler>
>char (&two_arg_handler_test(Handler, ...))[2];
>
>template <typename Handler, typename Arg1, typename Arg2>
>auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2)
> -> decltype(
> sizeof(Handler(static_cast<Handler&&>(h))),
> ((h)(*a1, static_cast<Arg2&&>(*a2))),
> char(0));
>
>template <typename Handler>
>char (&two_arg_move_handler_test(Handler, ...))[2];
># 113 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
>template <typename T> T& lvref();
>template <typename T> T& lvref(T);
>template <typename T> const T& clvref();
>template <typename T> const T& clvref(T);
>
>template <typename T> T rvref();
>template <typename T> T rvref(T);
>
>
>
>
>template <typename T> char argbyv(T);
>
>template <int>
>struct handler_type_requirements
>{
>};
># 554 "/usr/include/boost/asio/detail/handler_type_requirements.hpp" 3 4
>}
>}
>}
># 19 "/usr/include/boost/asio/impl/execution_context.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>class scoped_ptr
>{
>public:
>
> explicit scoped_ptr(T* p = 0)
> : p_(p)
> {
> }
>
>
> ~scoped_ptr()
> {
> delete p_;
> }
>
>
> T* get()
> {
> return p_;
> }
>
>
> T* operator->()
> {
> return p_;
> }
>
>
> T& operator*()
> {
> return *p_;
> }
>
>
> void reset(T* p = 0)
> {
> delete p_;
> p_ = p;
> }
>
>
> T* release()
> {
> T* tmp = p_;
> p_ = 0;
> return tmp;
> }
>
>private:
>
> scoped_ptr(const scoped_ptr&);
> scoped_ptr& operator=(const scoped_ptr&);
>
> T* p_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 88 "/usr/include/boost/asio/detail/scoped_ptr.hpp" 2 3 4
># 20 "/usr/include/boost/asio/impl/execution_context.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/service_registry.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/service_registry.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/mutex.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_mutex.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/posix_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/scoped_lock.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/scoped_lock.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/scoped_lock.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Mutex>
>class scoped_lock
> : private noncopyable
>{
>public:
>
> enum adopt_lock_t { adopt_lock };
>
>
> scoped_lock(Mutex& m, adopt_lock_t)
> : mutex_(m),
> locked_(true)
> {
> }
>
>
> explicit scoped_lock(Mutex& m)
> : mutex_(m)
> {
> mutex_.lock();
> locked_ = true;
> }
>
>
> ~scoped_lock()
> {
> if (locked_)
> mutex_.unlock();
> }
>
>
> void lock()
> {
> if (!locked_)
> {
> mutex_.lock();
> locked_ = true;
> }
> }
>
>
> void unlock()
> {
> if (locked_)
> {
> mutex_.unlock();
> locked_ = false;
> }
> }
>
>
> bool locked() const
> {
> return locked_;
> }
>
>
> Mutex& mutex()
> {
> return mutex_;
> }
>
>private:
>
> Mutex& mutex_;
>
>
> bool locked_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 102 "/usr/include/boost/asio/detail/scoped_lock.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class posix_event;
>
>class posix_mutex
> : private noncopyable
>{
>public:
> typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
>
>
> inline posix_mutex();
>
>
> ~posix_mutex()
> {
> ::pthread_mutex_destroy(&mutex_);
> }
>
>
> void lock()
> {
> (void)::pthread_mutex_lock(&mutex_);
> }
>
>
> void unlock()
> {
> (void)::pthread_mutex_unlock(&mutex_);
> }
>
>private:
> friend class posix_event;
> ::pthread_mutex_t mutex_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 71 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_mutex.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/throw_error.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/throw_error.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>inline void do_throw_error(const boost::system::error_code& err);
>
>inline void do_throw_error(const boost::system::error_code& err,
> const char* location);
>
>inline void throw_error(const boost::system::error_code& err)
>{
> if (err)
> do_throw_error(err);
>}
>
>inline void throw_error(const boost::system::error_code& err,
> const char* location)
>{
> if (err)
> do_throw_error(err, location);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 50 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/throw_error.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/throw_exception.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/throw_exception.hpp" 3 4
># 1 "/usr/include/boost/throw_exception.hpp" 1 3 4
>
>
>
> 
># 5 "/usr/include/boost/throw_exception.hpp" 3
># 29 "/usr/include/boost/throw_exception.hpp" 3
># 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/config/workaround.hpp" 1 3 4
># 9 "/usr/include/boost/detail/workaround.hpp" 2 3 4
># 30 "/usr/include/boost/throw_exception.hpp" 2 3
># 42 "/usr/include/boost/throw_exception.hpp" 3
># 1 "/usr/include/boost/exception/exception.hpp" 1 3 4
># 9 "/usr/include/boost/exception/exception.hpp" 3 4
> 
># 10 "/usr/include/boost/exception/exception.hpp" 3
># 19 "/usr/include/boost/exception/exception.hpp" 3
>namespace boost { template <class T> class shared_ptr; };
>namespace boost { namespace exception_detail { using boost::shared_ptr; } }
>
>
>namespace
>boost
> {
> namespace
> exception_detail
> {
> template <class T>
> class
> refcount_ptr
> {
> public:
>
> refcount_ptr():
> px_(0)
> {
> }
>
> ~refcount_ptr()
> {
> release();
> }
>
> refcount_ptr( refcount_ptr const & x ):
> px_(x.px_)
> {
> add_ref();
> }
>
> refcount_ptr &
> operator=( refcount_ptr const & x )
> {
> adopt(x.px_);
> return *this;
> }
>
> void
> adopt( T * px )
> {
> release();
> px_=px;
> add_ref();
> }
>
> T *
> get() const
> {
> return px_;
> }
>
> private:
>
> T * px_;
>
> void
> add_ref()
> {
> if( px_ )
> px_->add_ref();
> }
>
> void
> release()
> {
> if( px_ && px_->release() )
> px_=0;
> }
> };
> }
>
>
>
> template <class Tag,class T>
> class error_info;
>
> typedef error_info<struct throw_function_,char const *> throw_function;
> typedef error_info<struct throw_file_,char const *> throw_file;
> typedef error_info<struct throw_line_,int> throw_line;
>
> template <>
> class
> error_info<throw_function_,char const *>
> {
> public:
> typedef char const * value_type;
> value_type v_;
> explicit
> error_info( value_type v ):
> v_(v)
> {
> }
> };
>
> template <>
> class
> error_info<throw_file_,char const *>
> {
> public:
> typedef char const * value_type;
> value_type v_;
> explicit
> error_info( value_type v ):
> v_(v)
> {
> }
> };
>
> template <>
> class
> error_info<throw_line_,int>
> {
> public:
> typedef int value_type;
> value_type v_;
> explicit
> error_info( value_type v ):
> v_(v)
> {
> }
> };
>
>
>
>#pragma GCC visibility push (default)
>
>
> class exception;
>
>
>#pragma GCC visibility pop
>
>
>
> namespace
> exception_detail
> {
> class error_info_base;
> struct type_info_;
>
> struct
> error_info_container
> {
> virtual char const * diagnostic_information( char const * ) const = 0;
> virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
> virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
> virtual void add_ref() const = 0;
> virtual bool release() const = 0;
> virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
>
> protected:
>
> ~error_info_container() throw()
> {
> }
> };
>
> template <class>
> struct get_info;
>
> template <>
> struct get_info<throw_function>;
>
> template <>
> struct get_info<throw_file>;
>
> template <>
> struct get_info<throw_line>;
>
> template <class>
> struct set_info_rv;
>
> template <>
> struct set_info_rv<throw_function>;
>
> template <>
> struct set_info_rv<throw_file>;
>
> template <>
> struct set_info_rv<throw_line>;
>
> char const * get_diagnostic_information( exception const &, char const * );
>
> void copy_boost_exception( exception *, exception const * );
>
> template <class E,class Tag,class T>
> E const & set_info( E const &, error_info<Tag,T> const & );
>
> template <class E>
> E const & set_info( E const &, throw_function const & );
>
> template <class E>
> E const & set_info( E const &, throw_file const & );
>
> template <class E>
> E const & set_info( E const &, throw_line const & );
> }
>
>
>
>#pragma GCC visibility push (default)
>
>
> class
> exception
> {
>
> public:
> template <class Tag> void set( typename Tag::type const & );
> template <class Tag> typename Tag::type const * get() const;
>
>
> protected:
>
> exception():
> throw_function_(0),
> throw_file_(0),
> throw_line_(-1)
> {
> }
># 254 "/usr/include/boost/exception/exception.hpp" 3
> virtual ~exception() throw()
>
> = 0
>
> ;
>
>
>
>
> private:
>
> template <class E>
> friend E const & exception_detail::set_info( E const &, throw_function const & );
>
> template <class E>
> friend E const & exception_detail::set_info( E const &, throw_file const & );
>
> template <class E>
> friend E const & exception_detail::set_info( E const &, throw_line const & );
>
> template <class E,class Tag,class T>
> friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
>
> friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
>
> template <class>
> friend struct exception_detail::get_info;
> friend struct exception_detail::get_info<throw_function>;
> friend struct exception_detail::get_info<throw_file>;
> friend struct exception_detail::get_info<throw_line>;
> template <class>
> friend struct exception_detail::set_info_rv;
> friend struct exception_detail::set_info_rv<throw_function>;
> friend struct exception_detail::set_info_rv<throw_file>;
> friend struct exception_detail::set_info_rv<throw_line>;
> friend void exception_detail::copy_boost_exception( exception *, exception const * );
>
> mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
> mutable char const * throw_function_;
> mutable char const * throw_file_;
> mutable int throw_line_;
> };
>
>
>#pragma GCC visibility pop
>
>
>
> inline
> exception::
> ~exception() throw()
> {
> }
>
> namespace
> exception_detail
> {
> template <class E>
> E const &
> set_info( E const & x, throw_function const & y )
> {
> x.throw_function_=y.v_;
> return x;
> }
>
> template <class E>
> E const &
> set_info( E const & x, throw_file const & y )
> {
> x.throw_file_=y.v_;
> return x;
> }
>
> template <class E>
> E const &
> set_info( E const & x, throw_line const & y )
> {
> x.throw_line_=y.v_;
> return x;
> }
> }
>
>
>
> namespace
> exception_detail
> {
>
>
>#pragma GCC visibility push (default)
>
>
> template <class T>
> struct
> error_info_injector:
> public T,
> public exception
> {
> explicit
> error_info_injector( T const & x ):
> T(x)
> {
> }
>
> ~error_info_injector() throw()
> {
> }
> };
>
>
>#pragma GCC visibility pop
>
>
>
> struct large_size { char c[256]; };
> large_size dispatch_boost_exception( exception const * );
>
> struct small_size { };
> small_size dispatch_boost_exception( void const * );
>
> template <class,int>
> struct enable_error_info_helper;
>
> template <class T>
> struct
> enable_error_info_helper<T,sizeof(large_size)>
> {
> typedef T type;
> };
>
> template <class T>
> struct
> enable_error_info_helper<T,sizeof(small_size)>
> {
> typedef error_info_injector<T> type;
> };
>
> template <class T>
> struct
> enable_error_info_return_type
> {
> typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
> };
> }
>
> template <class T>
> inline
> typename
> exception_detail::enable_error_info_return_type<T>::type
> enable_error_info( T const & x )
> {
> typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
> return rt(x);
> }
>
>
>
> namespace
> exception_detail
> {
>
>
>#pragma GCC visibility push (default)
>
>
> class
> clone_base
> {
> public:
>
> virtual clone_base const * clone() const = 0;
> virtual void rethrow() const = 0;
>
> virtual
> ~clone_base() throw()
> {
> }
> };
>
>
>#pragma GCC visibility pop
>
>
>
> inline
> void
> copy_boost_exception( exception * a, exception const * b )
> {
> refcount_ptr<error_info_container> data;
> if( error_info_container * d=b->data_.get() )
> data = d->clone();
> a->throw_file_ = b->throw_file_;
> a->throw_line_ = b->throw_line_;
> a->throw_function_ = b->throw_function_;
> a->data_ = data;
> }
>
> inline
> void
> copy_boost_exception( void *, void const * )
> {
> }
>
>
>
>#pragma GCC visibility push (default)
>
>
> template <class T>
> class
> clone_impl:
> public T,
> public virtual clone_base
> {
> struct clone_tag { };
> clone_impl( clone_impl const & x, clone_tag ):
> T(x)
> {
> copy_boost_exception(this,&x);
> }
>
> public:
>
> explicit
> clone_impl( T const & x ):
> T(x)
> {
> copy_boost_exception(this,&x);
> }
>
> ~clone_impl() throw()
> {
> }
>
> private:
>
> clone_base const *
> clone() const
> {
> return new clone_impl(*this,clone_tag());
> }
>
> void
> rethrow() const
> {
> throw*this;
> }
> };
> }
>
>
>#pragma GCC visibility pop
>
>
>
> template <class T>
> inline
> exception_detail::clone_impl<T>
> enable_current_exception( T const & x )
> {
> return exception_detail::clone_impl<T>(x);
> }
> }
># 43 "/usr/include/boost/throw_exception.hpp" 2 3
>
># 1 "/usr/include/boost/current_function.hpp" 1 3 4
># 22 "/usr/include/boost/current_function.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>inline void current_function_helper()
>{
># 69 "/usr/include/boost/current_function.hpp" 3 4
>}
>
>}
>
>}
># 45 "/usr/include/boost/throw_exception.hpp" 2 3
>
>
>
>
>
>
>
>namespace boost
>{
>
>
>
>
>
>
>inline void throw_exception_assert_compatibility( std::exception const & ) { }
>
>template<class E> __attribute__ ((__noreturn__)) inline void throw_exception( E const & e )
>{
>
>
> throw_exception_assert_compatibility(e);
>
>
> throw enable_current_exception(enable_error_info(e));
>
>
>
>}
>
>
>
>
> namespace
> exception_detail
> {
> template <class E>
> __attribute__ ((__noreturn__))
> void
> throw_exception_( E const & x, char const * current_function, char const * file, int line )
> {
> boost::throw_exception(
> set_info(
> set_info(
> set_info(
> enable_error_info(x),
> throw_function(current_function)),
> throw_file(file)),
> throw_line(line)));
> }
> }
>
>}
># 22 "/usr/include/boost/asio/detail/throw_exception.hpp" 2 3 4
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using boost::throw_exception;
># 49 "/usr/include/boost/asio/detail/throw_exception.hpp" 3 4
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
># 1 "/usr/include/boost/system/system_error.hpp" 1 3 4
># 13 "/usr/include/boost/system/system_error.hpp" 3 4
># 1 "/usr/include/c++/8/cassert" 1 3 4
># 41 "/usr/include/c++/8/cassert" 3 4
> 
># 42 "/usr/include/c++/8/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)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 44 "/usr/include/c++/8/cassert" 2 3
># 14 "/usr/include/boost/system/system_error.hpp" 2 3 4
>
>
>namespace boost
>{
> namespace system
> {
>
>
> class __attribute__((__visibility__("default"))) system_error : public std::runtime_error
>
>
> {
> public:
> system_error( error_code ec )
> : std::runtime_error(""), m_error_code(ec) {}
>
> system_error( error_code ec, const std::string & what_arg )
> : std::runtime_error(what_arg), m_error_code(ec) {}
>
> system_error( error_code ec, const char* what_arg )
> : std::runtime_error(what_arg), m_error_code(ec) {}
>
> system_error( int ev, const error_category & ecat )
> : std::runtime_error(""), m_error_code(ev,ecat) {}
>
> system_error( int ev, const error_category & ecat,
> const std::string & what_arg )
> : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
>
> system_error( int ev, const error_category & ecat,
> const char * what_arg )
> : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
>
> virtual ~system_error() noexcept {}
>
> const error_code & code() const noexcept { return m_error_code; }
> const char * what() const noexcept;
>
> private:
> error_code m_error_code;
> mutable std::string m_what;
> };
>
>
>
> inline const char * system_error::what() const noexcept
>
> {
> if ( m_what.empty() )
> {
>
> try
>
> {
> m_what = this->std::runtime_error::what();
> if ( !m_what.empty() ) m_what += ": ";
> m_what += m_error_code.message();
> }
>
> catch (...) { return std::runtime_error::what(); }
>
> }
> return m_what.c_str();
> }
>
> }
>}
># 22 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>void do_throw_error(const boost::system::error_code& err)
>{
> boost::system::system_error e(err);
> boost::asio::detail::throw_exception(e);
>}
>
>void do_throw_error(const boost::system::error_code& err, const char* location)
>{
> boost::system::system_error e(err, location);
> boost::asio::detail::throw_exception(e);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 46 "/usr/include/boost/asio/detail/impl/throw_error.ipp" 2 3 4
># 53 "/usr/include/boost/asio/detail/throw_error.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
># 1 "/usr/include/boost/asio/error.hpp" 1 3 4
># 27 "/usr/include/boost/asio/error.hpp" 3 4
># 1 "/usr/include/c++/8/cerrno" 1 3 4
># 39 "/usr/include/c++/8/cerrno" 3 4
> 
># 40 "/usr/include/c++/8/cerrno" 3
># 28 "/usr/include/boost/asio/error.hpp" 2 3 4
># 1 "/usr/include/netdb.h" 1 3 4
># 27 "/usr/include/netdb.h" 3 4
># 1 "/usr/include/netinet/in.h" 1 3 4
># 23 "/usr/include/netinet/in.h" 3 4
># 1 "/usr/include/sys/socket.h" 1 3 4
># 24 "/usr/include/sys/socket.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/types/struct_iovec.h" 1 3 4
># 23 "/usr/include/bits/types/struct_iovec.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 24 "/usr/include/bits/types/struct_iovec.h" 2 3 4
>
>
>struct iovec
> {
> void *iov_base;
> size_t iov_len;
> };
># 27 "/usr/include/sys/socket.h" 2 3 4
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 29 "/usr/include/sys/socket.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/socket.h" 1 3 4
># 27 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 28 "/usr/include/bits/socket.h" 2 3 4
># 38 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/bits/socket_type.h" 1 3 4
># 24 "/usr/include/bits/socket_type.h" 3 4
>enum __socket_type
>{
> SOCK_STREAM = 1,
>
>
> SOCK_DGRAM = 2,
>
>
> SOCK_RAW = 3,
>
> SOCK_RDM = 4,
>
> SOCK_SEQPACKET = 5,
>
>
> SOCK_DCCP = 6,
>
> SOCK_PACKET = 10,
>
>
>
>
>
>
>
> SOCK_CLOEXEC = 02000000,
>
>
> SOCK_NONBLOCK = 00004000
>
>
>};
># 39 "/usr/include/bits/socket.h" 2 3 4
># 172 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/bits/sockaddr.h" 1 3 4
># 28 "/usr/include/bits/sockaddr.h" 3 4
>typedef unsigned short int sa_family_t;
># 173 "/usr/include/bits/socket.h" 2 3 4
>
>
>struct sockaddr
> {
> sa_family_t sa_family;
> char sa_data[14];
> };
># 188 "/usr/include/bits/socket.h" 3 4
>struct sockaddr_storage
> {
> sa_family_t ss_family;
> char __ss_padding[(128 - (sizeof (unsigned short int)) - sizeof (unsigned long int))];
> unsigned long int __ss_align;
> };
>
>
>
>enum
> {
> MSG_OOB = 0x01,
>
> MSG_PEEK = 0x02,
>
> MSG_DONTROUTE = 0x04,
>
>
>
> MSG_TRYHARD = MSG_DONTROUTE,
>
>
> MSG_CTRUNC = 0x08,
>
> MSG_PROXY = 0x10,
>
> MSG_TRUNC = 0x20,
>
> MSG_DONTWAIT = 0x40,
>
> MSG_EOR = 0x80,
>
> MSG_WAITALL = 0x100,
>
> MSG_FIN = 0x200,
>
> MSG_SYN = 0x400,
>
> MSG_CONFIRM = 0x800,
>
> MSG_RST = 0x1000,
>
> MSG_ERRQUEUE = 0x2000,
>
> MSG_NOSIGNAL = 0x4000,
>
> MSG_MORE = 0x8000,
>
> MSG_WAITFORONE = 0x10000,
>
> MSG_BATCH = 0x40000,
>
> MSG_ZEROCOPY = 0x4000000,
>
> MSG_FASTOPEN = 0x20000000,
>
>
> MSG_CMSG_CLOEXEC = 0x40000000
>
>
>
> };
>
>
>
>
>struct msghdr
> {
> void *msg_name;
> socklen_t msg_namelen;
>
> struct iovec *msg_iov;
> size_t msg_iovlen;
>
> void *msg_control;
> size_t msg_controllen;
>
>
>
>
> int msg_flags;
> };
>
>
>struct cmsghdr
> {
> size_t cmsg_len;
>
>
>
>
> int cmsg_level;
> int cmsg_type;
>
> __extension__ unsigned char __cmsg_data [];
>
> };
># 302 "/usr/include/bits/socket.h" 3 4
>extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
> struct cmsghdr *__cmsg) throw ();
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) struct cmsghdr *
>__attribute__ ((__leaf__)) __cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ()
>{
> if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
>
> return (struct cmsghdr *) 0;
>
> __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
> + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
> if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
> + __mhdr->msg_controllen)
> || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
> > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))
>
> return (struct cmsghdr *) 0;
> return __cmsg;
>}
>
>
>
>
>enum
> {
> SCM_RIGHTS = 0x01
>
>
> , SCM_CREDENTIALS = 0x02
>
>
> };
>
>
>
>struct ucred
>{
> pid_t pid;
> uid_t uid;
> gid_t gid;
>};
># 390 "/usr/include/bits/socket.h" 3 4
># 1 "/usr/include/asm/socket.h" 1 3 4
># 1 "/usr/include/asm-generic/socket.h" 1 3 4
>
>
>
>
># 1 "/usr/include/asm/sockios.h" 1 3 4
># 1 "/usr/include/asm-generic/sockios.h" 1 3 4
># 1 "/usr/include/asm/sockios.h" 2 3 4
># 6 "/usr/include/asm-generic/socket.h" 2 3 4
># 1 "/usr/include/asm/socket.h" 2 3 4
># 391 "/usr/include/bits/socket.h" 2 3 4
># 444 "/usr/include/bits/socket.h" 3 4
>struct linger
> {
> int l_onoff;
> int l_linger;
> };
># 34 "/usr/include/sys/socket.h" 2 3 4
>
>
># 1 "/usr/include/bits/types/struct_osockaddr.h" 1 3 4
>
>
>
>
>
>struct osockaddr
>{
> unsigned short int sa_family;
> unsigned char sa_data[14];
>};
># 37 "/usr/include/sys/socket.h" 2 3 4
>
>
>
>
>enum
>{
> SHUT_RD = 0,
>
> SHUT_WR,
>
> SHUT_RDWR
>
>};
># 90 "/usr/include/sys/socket.h" 3 4
>struct mmsghdr
> {
> struct msghdr msg_hdr;
> unsigned int msg_len;
>
> };
>
>
>
>
>
>
>extern int socket (int __domain, int __type, int __protocol) throw ();
>
>
>
>
>
>extern int socketpair (int __domain, int __type, int __protocol,
> int __fds[2]) throw ();
>
>
>extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
> throw ();
>
>
>extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __len) throw ();
># 126 "/usr/include/sys/socket.h" 3 4
>extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);
>
>
>
>extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __len) throw ();
>
>
>
>
>
>
>extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);
>
>
>
>
>
>
>extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);
>
>
>
>
>
>
>extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
> int __flags, const struct sockaddr * __addr,
> socklen_t __addr_len);
># 163 "/usr/include/sys/socket.h" 3 4
>extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
> int __flags, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __addr_len);
>
>
>
>
>
>
>
>extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
> int __flags);
>
>
>
>
>
>
>
>extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
> unsigned int __vlen, int __flags);
>
>
>
>
>
>
>
>extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
>
>
>
>
>
>
>
>extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
> unsigned int __vlen, int __flags,
> struct timespec *__tmo);
>
>
>
>
>
>
>extern int getsockopt (int __fd, int __level, int __optname,
> void *__restrict __optval,
> socklen_t *__restrict __optlen) throw ();
>
>
>
>
>extern int setsockopt (int __fd, int __level, int __optname,
> const void *__optval, socklen_t __optlen) throw ();
>
>
>
>
>
>extern int listen (int __fd, int __n) throw ();
># 232 "/usr/include/sys/socket.h" 3 4
>extern int accept (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __addr_len);
>
>
>
>
>
>
>extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
> socklen_t *__restrict __addr_len, int __flags);
># 250 "/usr/include/sys/socket.h" 3 4
>extern int shutdown (int __fd, int __how) throw ();
>
>
>
>
>extern int sockatmark (int __fd) throw ();
>
>
>
>
>
>
>
>extern int isfdtype (int __fd, int __fdtype) throw ();
># 272 "/usr/include/sys/socket.h" 3 4
>}
># 24 "/usr/include/netinet/in.h" 2 3 4
>
>
>
>extern "C" {
>
>
>typedef uint32_t in_addr_t;
>struct in_addr
> {
> in_addr_t s_addr;
> };
>
>
># 1 "/usr/include/bits/in.h" 1 3 4
># 142 "/usr/include/bits/in.h" 3 4
>struct ip_opts
> {
> struct in_addr ip_dst;
> char ip_opts[40];
> };
>
>
>struct ip_mreqn
> {
> struct in_addr imr_multiaddr;
> struct in_addr imr_address;
> int imr_ifindex;
> };
>
>
>struct in_pktinfo
> {
> int ipi_ifindex;
> struct in_addr ipi_spec_dst;
> struct in_addr ipi_addr;
> };
># 38 "/usr/include/netinet/in.h" 2 3 4
>
>
>enum
> {
> IPPROTO_IP = 0,
>
> IPPROTO_ICMP = 1,
>
> IPPROTO_IGMP = 2,
>
> IPPROTO_IPIP = 4,
>
> IPPROTO_TCP = 6,
>
> IPPROTO_EGP = 8,
>
> IPPROTO_PUP = 12,
>
> IPPROTO_UDP = 17,
>
> IPPROTO_IDP = 22,
>
> IPPROTO_TP = 29,
>
> IPPROTO_DCCP = 33,
>
> IPPROTO_IPV6 = 41,
>
> IPPROTO_RSVP = 46,
>
> IPPROTO_GRE = 47,
>
> IPPROTO_ESP = 50,
>
> IPPROTO_AH = 51,
>
> IPPROTO_MTP = 92,
>
> IPPROTO_BEETPH = 94,
>
> IPPROTO_ENCAP = 98,
>
> IPPROTO_PIM = 103,
>
> IPPROTO_COMP = 108,
>
> IPPROTO_SCTP = 132,
>
> IPPROTO_UDPLITE = 136,
>
> IPPROTO_MPLS = 137,
>
> IPPROTO_RAW = 255,
>
> IPPROTO_MAX
> };
>
>
>
>
>
>enum
> {
> IPPROTO_HOPOPTS = 0,
>
> IPPROTO_ROUTING = 43,
>
> IPPROTO_FRAGMENT = 44,
>
> IPPROTO_ICMPV6 = 58,
>
> IPPROTO_NONE = 59,
>
> IPPROTO_DSTOPTS = 60,
>
> IPPROTO_MH = 135
>
> };
>
>
>
>typedef uint16_t in_port_t;
>
>
>enum
> {
> IPPORT_ECHO = 7,
> IPPORT_DISCARD = 9,
> IPPORT_SYSTAT = 11,
> IPPORT_DAYTIME = 13,
> IPPORT_NETSTAT = 15,
> IPPORT_FTP = 21,
> IPPORT_TELNET = 23,
> IPPORT_SMTP = 25,
> IPPORT_TIMESERVER = 37,
> IPPORT_NAMESERVER = 42,
> IPPORT_WHOIS = 43,
> IPPORT_MTP = 57,
>
> IPPORT_TFTP = 69,
> IPPORT_RJE = 77,
> IPPORT_FINGER = 79,
> IPPORT_TTYLINK = 87,
> IPPORT_SUPDUP = 95,
>
>
> IPPORT_EXECSERVER = 512,
> IPPORT_LOGINSERVER = 513,
> IPPORT_CMDSERVER = 514,
> IPPORT_EFSSERVER = 520,
>
>
> IPPORT_BIFFUDP = 512,
> IPPORT_WHOSERVER = 513,
> IPPORT_ROUTESERVER = 520,
>
>
> IPPORT_RESERVED = 1024,
>
>
> IPPORT_USERRESERVED = 5000
> };
># 211 "/usr/include/netinet/in.h" 3 4
>struct in6_addr
> {
> union
> {
> uint8_t __u6_addr8[16];
> uint16_t __u6_addr16[8];
> uint32_t __u6_addr32[4];
> } __in6_u;
>
>
>
>
>
> };
>
>
>extern const struct in6_addr in6addr_any;
>extern const struct in6_addr in6addr_loopback;
># 237 "/usr/include/netinet/in.h" 3 4
>struct sockaddr_in
> {
> sa_family_t sin_family;
> in_port_t sin_port;
> struct in_addr sin_addr;
>
>
> unsigned char sin_zero[sizeof (struct sockaddr) -
> (sizeof (unsigned short int)) -
> sizeof (in_port_t) -
> sizeof (struct in_addr)];
> };
>
>
>
>struct sockaddr_in6
> {
> sa_family_t sin6_family;
> in_port_t sin6_port;
> uint32_t sin6_flowinfo;
> struct in6_addr sin6_addr;
> uint32_t sin6_scope_id;
> };
>
>
>
>
>struct ip_mreq
> {
>
> struct in_addr imr_multiaddr;
>
>
> struct in_addr imr_interface;
> };
>
>struct ip_mreq_source
> {
>
> struct in_addr imr_multiaddr;
>
>
> struct in_addr imr_interface;
>
>
> struct in_addr imr_sourceaddr;
> };
>
>
>
>
>struct ipv6_mreq
> {
>
> struct in6_addr ipv6mr_multiaddr;
>
>
> unsigned int ipv6mr_interface;
> };
>
>
>
>
>struct group_req
> {
>
> uint32_t gr_interface;
>
>
> struct sockaddr_storage gr_group;
> };
>
>struct group_source_req
> {
>
> uint32_t gsr_interface;
>
>
> struct sockaddr_storage gsr_group;
>
>
> struct sockaddr_storage gsr_source;
> };
>
>
>
>struct ip_msfilter
> {
>
> struct in_addr imsf_multiaddr;
>
>
> struct in_addr imsf_interface;
>
>
> uint32_t imsf_fmode;
>
>
> uint32_t imsf_numsrc;
>
> struct in_addr imsf_slist[1];
> };
>
>
>
>
>
>struct group_filter
> {
>
> uint32_t gf_interface;
>
>
> struct sockaddr_storage gf_group;
>
>
> uint32_t gf_fmode;
>
>
> uint32_t gf_numsrc;
>
> struct sockaddr_storage gf_slist[1];
>};
># 374 "/usr/include/netinet/in.h" 3 4
>extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
>extern uint16_t ntohs (uint16_t __netshort)
> throw () __attribute__ ((__const__));
>extern uint32_t htonl (uint32_t __hostlong)
> throw () __attribute__ ((__const__));
>extern uint16_t htons (uint16_t __hostshort)
> throw () __attribute__ ((__const__));
>
>
>
>
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 386 "/usr/include/netinet/in.h" 2 3 4
># 1 "/usr/include/bits/uintn-identity.h" 1 3 4
># 387 "/usr/include/netinet/in.h" 2 3 4
># 502 "/usr/include/netinet/in.h" 3 4
>extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
>
>
>extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
> throw ();
># 532 "/usr/include/netinet/in.h" 3 4
>struct cmsghdr;
>
>
>
>struct in6_pktinfo
> {
> struct in6_addr ipi6_addr;
> unsigned int ipi6_ifindex;
> };
>
>
>struct ip6_mtuinfo
> {
> struct sockaddr_in6 ip6m_addr;
> uint32_t ip6m_mtu;
> };
>
>
>
>extern int inet6_option_space (int __nbytes)
> throw () __attribute__ ((__deprecated__));
>extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
> int __type) throw () __attribute__ ((__deprecated__));
>extern int inet6_option_append (struct cmsghdr *__cmsg,
> const uint8_t *__typep, int __multx,
> int __plusy) throw () __attribute__ ((__deprecated__));
>extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
> int __multx, int __plusy)
> throw () __attribute__ ((__deprecated__));
>extern int inet6_option_next (const struct cmsghdr *__cmsg,
> uint8_t **__tptrp)
> throw () __attribute__ ((__deprecated__));
>extern int inet6_option_find (const struct cmsghdr *__cmsg,
> uint8_t **__tptrp, int __type)
> throw () __attribute__ ((__deprecated__));
>
>
>
>extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
>extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
> uint8_t __type, socklen_t __len, uint8_t __align,
> void **__databufp) throw ();
>extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
> throw ();
>extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
> socklen_t __vallen) throw ();
>extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
> uint8_t *__typep, socklen_t *__lenp,
> void **__databufp) throw ();
>extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
> uint8_t __type, socklen_t *__lenp,
> void **__databufp) throw ();
>extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
> socklen_t __vallen) throw ();
>
>
>
>extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
>extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
> int __segments) throw ();
>extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
>extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
>extern int inet6_rth_segments (const void *__bp) throw ();
>extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
> throw ();
>
>
>
>
>
>extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
> struct in_addr __group, uint32_t *__fmode,
> uint32_t *__numsrc, struct in_addr *__slist)
> throw ();
>
>
>extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
> struct in_addr __group, uint32_t __fmode,
> uint32_t __numsrc,
> const struct in_addr *__slist)
> throw ();
>
>
>
>extern int getsourcefilter (int __s, uint32_t __interface_addr,
> const struct sockaddr *__group,
> socklen_t __grouplen, uint32_t *__fmode,
> uint32_t *__numsrc,
> struct sockaddr_storage *__slist) throw ();
>
>
>extern int setsourcefilter (int __s, uint32_t __interface_addr,
> const struct sockaddr *__group,
> socklen_t __grouplen, uint32_t __fmode,
> uint32_t __numsrc,
> const struct sockaddr_storage *__slist) throw ();
>
>
>}
># 28 "/usr/include/netdb.h" 2 3 4
>
>
>
>
># 1 "/usr/include/rpc/netdb.h" 1 3 4
># 42 "/usr/include/rpc/netdb.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 43 "/usr/include/rpc/netdb.h" 2 3 4
>
>extern "C" {
>
>struct rpcent
>{
> char *r_name;
> char **r_aliases;
> int r_number;
>};
>
>extern void setrpcent (int __stayopen) throw ();
>extern void endrpcent (void) throw ();
>extern struct rpcent *getrpcbyname (const char *__name) throw ();
>extern struct rpcent *getrpcbynumber (int __number) throw ();
>extern struct rpcent *getrpcent (void) throw ();
>
>
>extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
> char *__buffer, size_t __buflen,
> struct rpcent **__result) throw ();
>
>extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
> char *__buffer, size_t __buflen,
> struct rpcent **__result) throw ();
>
>extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
> size_t __buflen, struct rpcent **__result) throw ();
>
>
>}
># 33 "/usr/include/netdb.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/types/sigevent_t.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/bits/types/sigevent_t.h" 2 3 4
>
># 1 "/usr/include/bits/types/__sigval_t.h" 1 3 4
># 24 "/usr/include/bits/types/__sigval_t.h" 3 4
>union sigval
>{
> int sival_int;
> void *sival_ptr;
>};
>
>typedef union sigval __sigval_t;
># 7 "/usr/include/bits/types/sigevent_t.h" 2 3 4
># 22 "/usr/include/bits/types/sigevent_t.h" 3 4
>typedef struct sigevent
> {
> __sigval_t sigev_value;
> int sigev_signo;
> int sigev_notify;
>
> union
> {
> int _pad[((64 / sizeof (int)) - 4)];
>
>
>
> __pid_t _tid;
>
> struct
> {
> void (*_function) (__sigval_t);
> pthread_attr_t *_attribute;
> } _sigev_thread;
> } _sigev_un;
> } sigevent_t;
># 37 "/usr/include/netdb.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/netdb.h" 1 3 4
># 26 "/usr/include/bits/netdb.h" 3 4
>struct netent
>{
> char *n_name;
> char **n_aliases;
> int n_addrtype;
> uint32_t n_net;
>};
># 41 "/usr/include/netdb.h" 2 3 4
># 51 "/usr/include/netdb.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
>extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
># 90 "/usr/include/netdb.h" 3 4
>extern void herror (const char *__str) throw ();
>
>
>extern const char *hstrerror (int __err_num) throw ();
>
>
>
>
>struct hostent
>{
> char *h_name;
> char **h_aliases;
> int h_addrtype;
> int h_length;
> char **h_addr_list;
>
>
>
>};
>
>
>
>
>
>
>extern void sethostent (int __stay_open);
>
>
>
>
>
>extern void endhostent (void);
>
>
>
>
>
>
>extern struct hostent *gethostent (void);
>
>
>
>
>
>
>extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
> int __type);
>
>
>
>
>
>extern struct hostent *gethostbyname (const char *__name);
># 153 "/usr/include/netdb.h" 3 4
>extern struct hostent *gethostbyname2 (const char *__name, int __af);
># 165 "/usr/include/netdb.h" 3 4
>extern int gethostent_r (struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
> int __type,
> struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int gethostbyname_r (const char *__restrict __name,
> struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int gethostbyname2_r (const char *__restrict __name, int __af,
> struct hostent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct hostent **__restrict __result,
> int *__restrict __h_errnop);
># 196 "/usr/include/netdb.h" 3 4
>extern void setnetent (int __stay_open);
>
>
>
>
>
>extern void endnetent (void);
>
>
>
>
>
>
>extern struct netent *getnetent (void);
>
>
>
>
>
>
>extern struct netent *getnetbyaddr (uint32_t __net, int __type);
>
>
>
>
>
>extern struct netent *getnetbyname (const char *__name);
># 235 "/usr/include/netdb.h" 3 4
>extern int getnetent_r (struct netent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct netent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int getnetbyaddr_r (uint32_t __net, int __type,
> struct netent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct netent **__restrict __result,
> int *__restrict __h_errnop);
>
>extern int getnetbyname_r (const char *__restrict __name,
> struct netent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct netent **__restrict __result,
> int *__restrict __h_errnop);
>
>
>
>
>struct servent
>{
> char *s_name;
> char **s_aliases;
> int s_port;
> char *s_proto;
>};
>
>
>
>
>
>
>extern void setservent (int __stay_open);
>
>
>
>
>
>extern void endservent (void);
>
>
>
>
>
>
>extern struct servent *getservent (void);
>
>
>
>
>
>
>extern struct servent *getservbyname (const char *__name, const char *__proto);
>
>
>
>
>
>
>extern struct servent *getservbyport (int __port, const char *__proto);
># 306 "/usr/include/netdb.h" 3 4
>extern int getservent_r (struct servent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct servent **__restrict __result);
>
>extern int getservbyname_r (const char *__restrict __name,
> const char *__restrict __proto,
> struct servent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct servent **__restrict __result);
>
>extern int getservbyport_r (int __port, const char *__restrict __proto,
> struct servent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct servent **__restrict __result);
>
>
>
>
>struct protoent
>{
> char *p_name;
> char **p_aliases;
> int p_proto;
>};
>
>
>
>
>
>
>extern void setprotoent (int __stay_open);
>
>
>
>
>
>extern void endprotoent (void);
>
>
>
>
>
>
>extern struct protoent *getprotoent (void);
>
>
>
>
>
>extern struct protoent *getprotobyname (const char *__name);
>
>
>
>
>
>extern struct protoent *getprotobynumber (int __proto);
># 372 "/usr/include/netdb.h" 3 4
>extern int getprotoent_r (struct protoent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct protoent **__restrict __result);
>
>extern int getprotobyname_r (const char *__restrict __name,
> struct protoent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct protoent **__restrict __result);
>
>extern int getprotobynumber_r (int __proto,
> struct protoent *__restrict __result_buf,
> char *__restrict __buf, size_t __buflen,
> struct protoent **__restrict __result);
># 393 "/usr/include/netdb.h" 3 4
>extern int setnetgrent (const char *__netgroup);
>
>
>
>
>
>
>
>extern void endnetgrent (void);
># 410 "/usr/include/netdb.h" 3 4
>extern int getnetgrent (char **__restrict __hostp,
> char **__restrict __userp,
> char **__restrict __domainp);
># 421 "/usr/include/netdb.h" 3 4
>extern int innetgr (const char *__netgroup, const char *__host,
> const char *__user, const char *__domain);
>
>
>
>
>
>
>
>extern int getnetgrent_r (char **__restrict __hostp,
> char **__restrict __userp,
> char **__restrict __domainp,
> char *__restrict __buffer, size_t __buflen);
># 449 "/usr/include/netdb.h" 3 4
>extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
> const char *__restrict __locuser,
> const char *__restrict __remuser,
> const char *__restrict __cmd, int *__restrict __fd2p);
># 461 "/usr/include/netdb.h" 3 4
>extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
> const char *__restrict __locuser,
> const char *__restrict __remuser,
> const char *__restrict __cmd, int *__restrict __fd2p,
> sa_family_t __af);
># 477 "/usr/include/netdb.h" 3 4
>extern int rexec (char **__restrict __ahost, int __rport,
> const char *__restrict __name,
> const char *__restrict __pass,
> const char *__restrict __cmd, int *__restrict __fd2p);
># 489 "/usr/include/netdb.h" 3 4
>extern int rexec_af (char **__restrict __ahost, int __rport,
> const char *__restrict __name,
> const char *__restrict __pass,
> const char *__restrict __cmd, int *__restrict __fd2p,
> sa_family_t __af);
># 503 "/usr/include/netdb.h" 3 4
>extern int ruserok (const char *__rhost, int __suser,
> const char *__remuser, const char *__locuser);
># 513 "/usr/include/netdb.h" 3 4
>extern int ruserok_af (const char *__rhost, int __suser,
> const char *__remuser, const char *__locuser,
> sa_family_t __af);
># 526 "/usr/include/netdb.h" 3 4
>extern int iruserok (uint32_t __raddr, int __suser,
> const char *__remuser, const char *__locuser);
># 537 "/usr/include/netdb.h" 3 4
>extern int iruserok_af (const void *__raddr, int __suser,
> const char *__remuser, const char *__locuser,
> sa_family_t __af);
># 549 "/usr/include/netdb.h" 3 4
>extern int rresvport (int *__alport);
># 558 "/usr/include/netdb.h" 3 4
>extern int rresvport_af (int *__alport, sa_family_t __af);
>
>
>
>
>
>
>struct addrinfo
>{
> int ai_flags;
> int ai_family;
> int ai_socktype;
> int ai_protocol;
> socklen_t ai_addrlen;
> struct sockaddr *ai_addr;
> char *ai_canonname;
> struct addrinfo *ai_next;
>};
>
>
>
>struct gaicb
>{
> const char *ar_name;
> const char *ar_service;
> const struct addrinfo *ar_request;
> struct addrinfo *ar_result;
>
> int __return;
> int __glibc_reserved[5];
>};
># 660 "/usr/include/netdb.h" 3 4
>extern int getaddrinfo (const char *__restrict __name,
> const char *__restrict __service,
> const struct addrinfo *__restrict __req,
> struct addrinfo **__restrict __pai);
>
>
>extern void freeaddrinfo (struct addrinfo *__ai) throw ();
>
>
>extern const char *gai_strerror (int __ecode) throw ();
>
>
>
>
>
>extern int getnameinfo (const struct sockaddr *__restrict __sa,
> socklen_t __salen, char *__restrict __host,
> socklen_t __hostlen, char *__restrict __serv,
> socklen_t __servlen, int __flags);
># 690 "/usr/include/netdb.h" 3 4
>extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
> int __ent, struct sigevent *__restrict __sig);
># 701 "/usr/include/netdb.h" 3 4
>extern int gai_suspend (const struct gaicb *const __list[], int __ent,
> const struct timespec *__timeout);
>
>
>extern int gai_error (struct gaicb *__req) throw ();
>
>
>extern int gai_cancel (struct gaicb *__gaicbp) throw ();
>
>
>}
># 29 "/usr/include/boost/asio/error.hpp" 2 3 4
># 62 "/usr/include/boost/asio/error.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 63 "/usr/include/boost/asio/error.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace error {
>
>enum basic_errors
>{
>
> access_denied = 13,
>
>
> address_family_not_supported = 97,
>
>
> address_in_use = 98,
>
>
> already_connected = 106,
>
>
> already_started = 114,
>
>
> broken_pipe = 32
>
> ,
>
>
> connection_aborted = 103,
>
>
> connection_refused = 111,
>
>
> connection_reset = 104,
>
>
> bad_descriptor = 9,
>
>
> fault = 14,
>
>
> host_unreachable = 113,
>
>
> in_progress = 115,
>
>
> interrupted = 4,
>
>
> invalid_argument = 22,
>
>
> message_size = 90,
>
>
> name_too_long = 36,
>
>
> network_down = 100,
>
>
> network_reset = 102,
>
>
> network_unreachable = 101,
>
>
> no_descriptors = 24,
>
>
> no_buffer_space = 105,
>
>
> no_memory = 12
>
> ,
>
>
> no_permission = 1
>
> ,
>
>
> no_protocol_option = 92,
>
>
> no_such_device = 19
>
> ,
>
>
> not_connected = 107,
>
>
> not_socket = 88,
>
>
> operation_aborted = 125
>
> ,
>
>
> operation_not_supported = 95,
>
>
> shut_down = 108,
>
>
> timed_out = 110,
>
>
> try_again = 11
>
> ,
>
>
> would_block = 11
>};
>
>enum netdb_errors
>{
>
> host_not_found = 1,
>
>
> host_not_found_try_again = 2,
>
>
> no_data = 4,
>
>
> no_recovery = 3
>};
>
>enum addrinfo_errors
>{
>
> service_not_found = -8
>
> ,
>
>
> socket_type_not_supported = -7
>
>
>};
>
>enum misc_errors
>{
>
> already_open = 1,
>
>
> eof,
>
>
> not_found,
>
>
> fd_set_failure
>};
>
>inline const boost::system::error_category& get_system_category()
>{
> return boost::system::system_category();
>}
>
>
>
>extern inline
>const boost::system::error_category& get_netdb_category();
>
>extern inline
>const boost::system::error_category& get_addrinfo_category();
># 255 "/usr/include/boost/asio/error.hpp" 3 4
>extern inline
>const boost::system::error_category& get_misc_category();
>
>static const boost::system::error_category&
> system_category __attribute__((__unused__))
> = boost::asio::error::get_system_category();
>static const boost::system::error_category&
> netdb_category __attribute__((__unused__))
> = boost::asio::error::get_netdb_category();
>static const boost::system::error_category&
> addrinfo_category __attribute__((__unused__))
> = boost::asio::error::get_addrinfo_category();
>static const boost::system::error_category&
> misc_category __attribute__((__unused__))
> = boost::asio::error::get_misc_category();
>
>}
>}
>}
>
>namespace boost {
>namespace system {
>
>template<> struct is_error_code_enum<boost::asio::error::basic_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::error::misc_errors>
>{
> static const bool value = true;
>};
>
>}
>}
>
>namespace boost {
>namespace asio {
>namespace error {
>
>inline boost::system::error_code make_error_code(basic_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_system_category());
>}
>
>inline boost::system::error_code make_error_code(netdb_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_netdb_category());
>}
>
>inline boost::system::error_code make_error_code(addrinfo_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_addrinfo_category());
>}
>
>inline boost::system::error_code make_error_code(misc_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_misc_category());
>}
>
>}
>namespace stream_errc {
>
> using error::eof;
> using error::not_found;
>}
>namespace socket_errc {
>
> using error::already_open;
> using error::not_found;
>}
>namespace resolver_errc {
>
> using error::host_not_found;
> const error::netdb_errors try_again = error::host_not_found_try_again;
> using error::service_not_found;
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 350 "/usr/include/boost/asio/error.hpp" 2 3 4
># 358 "/usr/include/boost/asio/error.hpp" 3 4
># 1 "/usr/include/boost/asio/impl/error.ipp" 1 3 4
># 20 "/usr/include/boost/asio/impl/error.ipp" 3 4
># 1 "/usr/include/boost/asio/error.hpp" 1 3 4
># 21 "/usr/include/boost/asio/impl/error.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/impl/error.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace error {
>
>
>
>namespace detail {
>
>class netdb_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.netdb";
> }
>
> std::string message(int value) const
> {
> if (value == error::host_not_found)
> return "Host not found (authoritative)";
> if (value == error::host_not_found_try_again)
> return "Host not found (non-authoritative), try again later";
> if (value == error::no_data)
> return "The query is valid, but it does not have associated data";
> if (value == error::no_recovery)
> return "A non-recoverable error occurred during database lookup";
> return "asio.netdb error";
> }
>};
>
>}
>
>const boost::system::error_category& get_netdb_category()
>{
> static detail::netdb_category instance;
> return instance;
>}
>
>namespace detail {
>
>class addrinfo_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.addrinfo";
> }
>
> std::string message(int value) const
> {
> if (value == error::service_not_found)
> return "Service not found";
> if (value == error::socket_type_not_supported)
> return "Socket type not supported";
> return "asio.addrinfo error";
> }
>};
>
>}
>
>const boost::system::error_category& get_addrinfo_category()
>{
> static detail::addrinfo_category instance;
> return instance;
>}
>
>
>
>namespace detail {
>
>class misc_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.misc";
> }
>
> std::string message(int value) const
> {
> if (value == error::already_open)
> return "Already open";
> if (value == error::eof)
> return "End of file";
> if (value == error::not_found)
> return "Element not found";
> if (value == error::fd_set_failure)
> return "The descriptor does not fit into the select call's fd_set";
> return "asio.misc error";
> }
>};
>
>}
>
>const boost::system::error_category& get_misc_category()
>{
> static detail::misc_category instance;
> return instance;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 129 "/usr/include/boost/asio/impl/error.ipp" 2 3 4
># 359 "/usr/include/boost/asio/error.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>posix_mutex::posix_mutex()
>{
> int error = ::pthread_mutex_init(&mutex_, 0);
> boost::system::error_code ec(error,
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "mutex");
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 45 "/usr/include/boost/asio/detail/impl/posix_mutex.ipp" 2 3 4
># 74 "/usr/include/boost/asio/detail/posix_mutex.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/mutex.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef posix_mutex mutex;
>
>
>
>
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/execution_context.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class io_context;
>
>namespace detail {
>
>template <typename T>
>class typeid_wrapper {};
>
>class service_registry
> : private noncopyable
>{
>public:
>
> inline service_registry(execution_context& owner);
>
>
> inline ~service_registry();
>
>
> inline void shutdown_services();
>
>
> inline void destroy_services();
>
>
> inline void notify_fork(execution_context::fork_event fork_ev);
>
>
>
>
> template <typename Service>
> Service& use_service();
>
>
>
>
>
>
> template <typename Service>
> Service& use_service(io_context& owner);
>
>
>
> template <typename Service>
> void add_service(Service* new_service);
>
>
> template <typename Service>
> bool has_service() const;
>
>private:
>
> template <typename Service>
> static void init_key(execution_context::service::key& key, ...);
>
>
>
> template <typename Service>
> static void init_key(execution_context::service::key& key,
> typename enable_if<
> is_base_of<typename Service::key_type, Service>::value>::type*);
>
>
>
> inline static void init_key_from_id(
> execution_context::service::key& key,
> const execution_context::id& id);
>
>
>
> template <typename Service>
> static void init_key_from_id(execution_context::service::key& key,
> const service_id<Service>& );
>
>
>
> inline static bool keys_match(
> const execution_context::service::key& key1,
> const execution_context::service::key& key2);
>
>
> typedef execution_context::service*(*factory_type)(void*);
>
>
> template <typename Service, typename Owner>
> static execution_context::service* create(void* owner);
>
>
> inline static void destroy(execution_context::service* service);
>
>
> struct auto_service_ptr;
> friend struct auto_service_ptr;
> struct auto_service_ptr
> {
> execution_context::service* ptr_;
> ~auto_service_ptr() { destroy(ptr_); }
> };
>
>
>
>
> inline execution_context::service* do_use_service(
> const execution_context::service::key& key,
> factory_type factory, void* owner);
>
>
>
> inline void do_add_service(
> const execution_context::service::key& key,
> execution_context::service* new_service);
>
>
> inline bool do_has_service(
> const execution_context::service::key& key) const;
>
>
> mutable boost::asio::detail::mutex mutex_;
>
>
> execution_context& owner_;
>
>
> execution_context::service* first_service_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 160 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 19 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Service>
>Service& service_registry::use_service()
>{
> execution_context::service::key key;
> init_key<Service>(key, 0);
> factory_type factory = &service_registry::create<Service, execution_context>;
> return *static_cast<Service*>(do_use_service(key, factory, &owner_));
>}
>
>template <typename Service>
>Service& service_registry::use_service(io_context& owner)
>{
> execution_context::service::key key;
> init_key<Service>(key, 0);
> factory_type factory = &service_registry::create<Service, io_context>;
> return *static_cast<Service*>(do_use_service(key, factory, &owner));
>}
>
>template <typename Service>
>void service_registry::add_service(Service* new_service)
>{
> execution_context::service::key key;
> init_key<Service>(key, 0);
> return do_add_service(key, new_service);
>}
>
>template <typename Service>
>bool service_registry::has_service() const
>{
> execution_context::service::key key;
> init_key<Service>(key, 0);
> return do_has_service(key);
>}
>
>template <typename Service>
>inline void service_registry::init_key(
> execution_context::service::key& key, ...)
>{
> init_key_from_id(key, Service::id);
>}
>
>
>template <typename Service>
>void service_registry::init_key(execution_context::service::key& key,
> typename enable_if<
> is_base_of<typename Service::key_type, Service>::value>::type*)
>{
> key.type_info_ = &typeid(typeid_wrapper<Service>);
> key.id_ = 0;
>}
>
>template <typename Service>
>void service_registry::init_key_from_id(execution_context::service::key& key,
> const service_id<Service>& )
>{
> key.type_info_ = &typeid(typeid_wrapper<Service>);
> key.id_ = 0;
>}
>
>
>template <typename Service, typename Owner>
>execution_context::service* service_registry::create(void* owner)
>{
> return new Service(*static_cast<Owner*>(owner));
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 95 "/usr/include/boost/asio/detail/impl/service_registry.hpp" 2 3 4
># 162 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/service_registry.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>service_registry::service_registry(execution_context& owner)
> : owner_(owner),
> first_service_(0)
>{
>}
>
>service_registry::~service_registry()
>{
>}
>
>void service_registry::shutdown_services()
>{
> execution_context::service* service = first_service_;
> while (service)
> {
> service->shutdown();
> service = service->next_;
> }
>}
>
>void service_registry::destroy_services()
>{
> while (first_service_)
> {
> execution_context::service* next_service = first_service_->next_;
> destroy(first_service_);
> first_service_ = next_service;
> }
>}
>
>void service_registry::notify_fork(execution_context::fork_event fork_ev)
>{
>
>
>
> std::vector<execution_context::service*> services;
> {
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
> execution_context::service* service = first_service_;
> while (service)
> {
> services.push_back(service);
> service = service->next_;
> }
> }
>
>
>
>
>
> std::size_t num_services = services.size();
> if (fork_ev == execution_context::fork_prepare)
> for (std::size_t i = 0; i < num_services; ++i)
> services[i]->notify_fork(fork_ev);
> else
> for (std::size_t i = num_services; i > 0; --i)
> services[i - 1]->notify_fork(fork_ev);
>}
>
>void service_registry::init_key_from_id(execution_context::service::key& key,
> const execution_context::id& id)
>{
> key.type_info_ = 0;
> key.id_ = &id;
>}
>
>bool service_registry::keys_match(
> const execution_context::service::key& key1,
> const execution_context::service::key& key2)
>{
> if (key1.id_ && key2.id_)
> if (key1.id_ == key2.id_)
> return true;
> if (key1.type_info_ && key2.type_info_)
> if (*key1.type_info_ == *key2.type_info_)
> return true;
> return false;
>}
>
>void service_registry::destroy(execution_context::service* service)
>{
> delete service;
>}
>
>execution_context::service* service_registry::do_use_service(
> const execution_context::service::key& key,
> factory_type factory, void* owner)
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
>
> execution_context::service* service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> return service;
> service = service->next_;
> }
>
>
>
>
> lock.unlock();
> auto_service_ptr new_service = { factory(owner) };
> new_service.ptr_->key_ = key;
> lock.lock();
>
>
>
> service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> return service;
> service = service->next_;
> }
>
>
> new_service.ptr_->next_ = first_service_;
> first_service_ = new_service.ptr_;
> new_service.ptr_ = 0;
> return first_service_;
>}
>
>void service_registry::do_add_service(
> const execution_context::service::key& key,
> execution_context::service* new_service)
>{
> if (&owner_ != &new_service->context())
> boost::asio::detail::throw_exception(invalid_service_owner());
>
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
>
> execution_context::service* service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> boost::asio::detail::throw_exception(service_already_exists());
> service = service->next_;
> }
>
>
> new_service->key_ = key;
> new_service->next_ = first_service_;
> first_service_ = new_service;
>}
>
>bool service_registry::do_has_service(
> const execution_context::service::key& key) const
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> execution_context::service* service = first_service_;
> while (service)
> {
> if (keys_match(service->key_, key))
> return true;
> service = service->next_;
> }
>
> return false;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 198 "/usr/include/boost/asio/detail/impl/service_registry.ipp" 2 3 4
># 164 "/usr/include/boost/asio/detail/service_registry.hpp" 2 3 4
># 21 "/usr/include/boost/asio/impl/execution_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/impl/execution_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename Service>
>inline Service& use_service(execution_context& e)
>{
>
> (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
>
> return e.service_registry_->template use_service<Service>();
>}
>
>
>
>
>template <typename Service, typename... Args>
>Service& make_service(execution_context& e, Args&&... args)
>{
> detail::scoped_ptr<Service> svc(
> new Service(e, static_cast<Args&&>(args)...));
> e.service_registry_->template add_service<Service>(svc.get());
> Service& result = *svc;
> svc.release();
> return result;
>}
># 81 "/usr/include/boost/asio/impl/execution_context.hpp" 3 4
>template <typename Service>
>inline void add_service(execution_context& e, Service* svc)
>{
>
> (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
>
> e.service_registry_->template add_service<Service>(svc);
>}
>
>template <typename Service>
>inline bool has_service(execution_context& e)
>{
>
> (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
>
> return e.service_registry_->template has_service<Service>();
>}
>
>inline execution_context& execution_context::service::context()
>{
> return owner_;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 108 "/usr/include/boost/asio/impl/execution_context.hpp" 2 3 4
># 409 "/usr/include/boost/asio/execution_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/execution_context.ipp" 1 3 4
># 22 "/usr/include/boost/asio/impl/execution_context.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/impl/execution_context.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>execution_context::execution_context()
> : service_registry_(new boost::asio::detail::service_registry(*this))
>{
>}
>
>execution_context::~execution_context()
>{
> shutdown();
> destroy();
> delete service_registry_;
>}
>
>void execution_context::shutdown()
>{
> service_registry_->shutdown_services();
>}
>
>void execution_context::destroy()
>{
> service_registry_->destroy_services();
>}
>
>void execution_context::notify_fork(
> boost::asio::execution_context::fork_event event)
>{
> service_registry_->notify_fork(event);
>}
>
>execution_context::service::service(execution_context& owner)
> : owner_(owner),
> next_(0)
>{
>}
>
>execution_context::service::~service()
>{
>}
>
>void execution_context::service::notify_fork(execution_context::fork_event)
>{
>}
>
>service_already_exists::service_already_exists()
> : std::logic_error("Service already exists.")
>{
>}
>
>invalid_service_owner::invalid_service_owner()
> : std::logic_error("Invalid service owner.")
>{
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 83 "/usr/include/boost/asio/impl/execution_context.ipp" 2 3 4
># 411 "/usr/include/boost/asio/execution_context.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/atomic_count.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/atomic_count.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>typedef std::atomic<long> atomic_count;
>inline void increment(atomic_count& a, long b) { a += b; }
>
>
>
>
>
>}
>}
>}
># 23 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class conditionally_enabled_mutex
> : private noncopyable
>{
>public:
>
> class scoped_lock
> : private noncopyable
> {
> public:
>
> enum adopt_lock_t { adopt_lock };
>
>
> scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t)
> : mutex_(m),
> locked_(m.enabled_)
> {
> }
>
>
> explicit scoped_lock(conditionally_enabled_mutex& m)
> : mutex_(m)
> {
> if (m.enabled_)
> {
> mutex_.mutex_.lock();
> locked_ = true;
> }
> else
> locked_ = false;
> }
>
>
> ~scoped_lock()
> {
> if (locked_)
> mutex_.mutex_.unlock();
> }
>
>
> void lock()
> {
> if (mutex_.enabled_ && !locked_)
> {
> mutex_.mutex_.lock();
> locked_ = true;
> }
> }
>
>
> void unlock()
> {
> if (locked_)
> {
> mutex_.unlock();
> locked_ = false;
> }
> }
>
>
> bool locked() const
> {
> return locked_;
> }
>
>
> boost::asio::detail::mutex& mutex()
> {
> return mutex_.mutex_;
> }
>
> private:
> friend class conditionally_enabled_event;
> conditionally_enabled_mutex& mutex_;
> bool locked_;
> };
>
>
> explicit conditionally_enabled_mutex(bool enabled)
> : enabled_(enabled)
> {
> }
>
>
> ~conditionally_enabled_mutex()
> {
> }
>
>
> bool enabled() const
> {
> return enabled_;
> }
>
>
> void lock()
> {
> if (enabled_)
> mutex_.lock();
> }
>
>
> void unlock()
> {
> if (enabled_)
> mutex_.unlock();
> }
>
>private:
> friend class scoped_lock;
> friend class conditionally_enabled_event;
> boost::asio::detail::mutex mutex_;
> const bool enabled_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 150 "/usr/include/boost/asio/detail/conditionally_enabled_mutex.hpp" 2 3 4
># 20 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/event.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/event.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_event.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/posix_event.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/assert.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/assert.hpp" 3 4
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 58 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 59 "/usr/include/boost/assert.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/assert.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class posix_event
> : private noncopyable
>{
>public:
>
> inline posix_event();
>
>
> ~posix_event()
> {
> ::pthread_cond_destroy(&cond_);
> }
>
>
> template <typename Lock>
> void signal(Lock& lock)
> {
> this->signal_all(lock);
> }
>
>
> template <typename Lock>
> void signal_all(Lock& lock)
> {
> (static_cast <bool> (lock.locked()) ? void (0) : __assert_fail ("lock.locked()", "/usr/include/boost/asio/detail/posix_event.hpp", 56, __extension__ __PRETTY_FUNCTION__));
> (void)lock;
> state_ |= 1;
> ::pthread_cond_broadcast(&cond_);
> }
>
>
> template <typename Lock>
> void unlock_and_signal_one(Lock& lock)
> {
> (static_cast <bool> (lock.locked()) ? void (0) : __assert_fail ("lock.locked()", "/usr/include/boost/asio/detail/posix_event.hpp", 66, __extension__ __PRETTY_FUNCTION__));
> state_ |= 1;
> bool have_waiters = (state_ > 1);
> lock.unlock();
> if (have_waiters)
> ::pthread_cond_signal(&cond_);
> }
>
>
> template <typename Lock>
> bool maybe_unlock_and_signal_one(Lock& lock)
> {
> (static_cast <bool> (lock.locked()) ? void (0) : __assert_fail ("lock.locked()", "/usr/include/boost/asio/detail/posix_event.hpp", 78, __extension__ __PRETTY_FUNCTION__));
> state_ |= 1;
> if (state_ > 1)
> {
> lock.unlock();
> ::pthread_cond_signal(&cond_);
> return true;
> }
> return false;
> }
>
>
> template <typename Lock>
> void clear(Lock& lock)
> {
> (static_cast <bool> (lock.locked()) ? void (0) : __assert_fail ("lock.locked()", "/usr/include/boost/asio/detail/posix_event.hpp", 93, __extension__ __PRETTY_FUNCTION__));
> (void)lock;
> state_ &= ~std::size_t(1);
> }
>
>
> template <typename Lock>
> void wait(Lock& lock)
> {
> (static_cast <bool> (lock.locked()) ? void (0) : __assert_fail ("lock.locked()", "/usr/include/boost/asio/detail/posix_event.hpp", 102, __extension__ __PRETTY_FUNCTION__));
> while ((state_ & 1) == 0)
> {
> state_ += 2;
> ::pthread_cond_wait(&cond_, &lock.mutex().mutex_);
> state_ -= 2;
> }
> }
>
>
> template <typename Lock>
> bool wait_for_usec(Lock& lock, long usec)
> {
> (static_cast <bool> (lock.locked()) ? void (0) : __assert_fail ("lock.locked()", "/usr/include/boost/asio/detail/posix_event.hpp", 115, __extension__ __PRETTY_FUNCTION__));
> if ((state_ & 1) == 0)
> {
> state_ += 2;
> timespec ts;
># 128 "/usr/include/boost/asio/detail/posix_event.hpp" 3 4
> if (::clock_gettime(1, &ts) == 0)
> {
> ts.tv_sec += usec / 1000000;
> ts.tv_nsec = (usec % 1000000) * 1000;
> ts.tv_sec += ts.tv_nsec / 1000000000;
> ts.tv_nsec = ts.tv_nsec % 1000000000;
> ::pthread_cond_timedwait(&cond_,
> &lock.mutex().mutex_, &ts);
> }
>
>
> state_ -= 2;
> }
> return (state_ & 1) != 0;
> }
>
>private:
> ::pthread_cond_t cond_;
> std::size_t state_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 154 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_event.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>posix_event::posix_event()
> : state_(0)
>{
>
>
>
>
>
> ::pthread_condattr_t attr;
> ::pthread_condattr_init(&attr);
> int error = ::pthread_condattr_setclock(&attr, 1);
> if (error == 0)
> error = ::pthread_cond_init(&cond_, &attr);
>
>
>
> boost::system::error_code ec(error,
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "event");
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 58 "/usr/include/boost/asio/detail/impl/posix_event.ipp" 2 3 4
># 157 "/usr/include/boost/asio/detail/posix_event.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/event.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef posix_event event;
>
>
>
>
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/null_event.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/null_event.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/null_event.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class null_event
> : private noncopyable
>{
>public:
>
> null_event()
> {
> }
>
>
> ~null_event()
> {
> }
>
>
> template <typename Lock>
> void signal(Lock&)
> {
> }
>
>
> template <typename Lock>
> void signal_all(Lock&)
> {
> }
>
>
> template <typename Lock>
> void unlock_and_signal_one(Lock&)
> {
> }
>
>
> template <typename Lock>
> bool maybe_unlock_and_signal_one(Lock&)
> {
> return false;
> }
>
>
> template <typename Lock>
> void clear(Lock&)
> {
> }
>
>
> template <typename Lock>
> void wait(Lock&)
> {
> do_wait();
> }
>
>
> template <typename Lock>
> bool wait_for_usec(Lock&, long usec)
> {
> do_wait_for_usec(usec);
> return true;
> }
>
>private:
> inline static void do_wait();
> inline static void do_wait_for_usec(long usec);
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 97 "/usr/include/boost/asio/detail/null_event.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/null_event.ipp" 1 3 4
># 34 "/usr/include/boost/asio/detail/impl/null_event.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 35 "/usr/include/boost/asio/detail/impl/null_event.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>void null_event::do_wait()
>{
>
>
>
>
>
> ::pause();
>
>}
>
>void null_event::do_wait_for_usec(long usec)
>{
># 63 "/usr/include/boost/asio/detail/impl/null_event.ipp" 3 4
> timeval tv;
> tv.tv_sec = usec / 1000000;
> tv.tv_usec = usec % 1000000;
> ::select(0, 0, 0, 0, &tv);
>
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 75 "/usr/include/boost/asio/detail/impl/null_event.ipp" 2 3 4
># 100 "/usr/include/boost/asio/detail/null_event.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class conditionally_enabled_event
> : private noncopyable
>{
>public:
>
> conditionally_enabled_event()
> {
> }
>
>
> ~conditionally_enabled_event()
> {
> }
>
>
> void signal(conditionally_enabled_mutex::scoped_lock& lock)
> {
> if (lock.mutex_.enabled_)
> event_.signal(lock);
> }
>
>
> void signal_all(conditionally_enabled_mutex::scoped_lock& lock)
> {
> if (lock.mutex_.enabled_)
> event_.signal_all(lock);
> }
>
>
> void unlock_and_signal_one(
> conditionally_enabled_mutex::scoped_lock& lock)
> {
> if (lock.mutex_.enabled_)
> event_.unlock_and_signal_one(lock);
> }
>
>
> bool maybe_unlock_and_signal_one(
> conditionally_enabled_mutex::scoped_lock& lock)
> {
> if (lock.mutex_.enabled_)
> return event_.maybe_unlock_and_signal_one(lock);
> else
> return false;
> }
>
>
> void clear(conditionally_enabled_mutex::scoped_lock& lock)
> {
> if (lock.mutex_.enabled_)
> event_.clear(lock);
> }
>
>
> void wait(conditionally_enabled_mutex::scoped_lock& lock)
> {
> if (lock.mutex_.enabled_)
> event_.wait(lock);
> else
> null_event().wait(lock);
> }
>
>
> bool wait_for_usec(
> conditionally_enabled_mutex::scoped_lock& lock, long usec)
> {
> if (lock.mutex_.enabled_)
> return event_.wait_for_usec(lock, usec);
> else
> return null_event().wait_for_usec(lock, usec);
> }
>
>private:
> boost::asio::detail::event event_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 113 "/usr/include/boost/asio/detail/conditionally_enabled_event.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef class epoll_reactor reactor;
># 38 "/usr/include/boost/asio/detail/reactor_fwd.hpp" 3 4
>}
>}
>}
># 27 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct scheduler_thread_info;
>
>class scheduler
> : public execution_context_service_base<scheduler>,
> public thread_context
>{
>public:
> typedef scheduler_operation operation;
>
>
>
> inline scheduler(boost::asio::execution_context& ctx,
> int concurrency_hint = 0);
>
>
> inline void shutdown();
>
>
> inline void init_task();
>
>
> inline std::size_t run(boost::system::error_code& ec);
>
>
> inline std::size_t run_one(boost::system::error_code& ec);
>
>
> inline std::size_t wait_one(
> long usec, boost::system::error_code& ec);
>
>
> inline std::size_t poll(boost::system::error_code& ec);
>
>
> inline std::size_t poll_one(boost::system::error_code& ec);
>
>
> inline void stop();
>
>
> inline bool stopped() const;
>
>
> inline void restart();
>
>
> void work_started()
> {
> ++outstanding_work_;
> }
>
>
>
> inline void compensating_work_started();
>
>
> void work_finished()
> {
> if (--outstanding_work_ == 0)
> stop();
> }
>
>
> bool can_dispatch()
> {
> return thread_call_stack::contains(this) != 0;
> }
>
>
>
> inline void post_immediate_completion(
> operation* op, bool is_continuation);
>
>
>
> inline void post_deferred_completion(operation* op);
>
>
>
> inline void post_deferred_completions(op_queue<operation>& ops);
>
>
>
> inline void do_dispatch(operation* op);
>
>
>
> inline void abandon_operations(op_queue<operation>& ops);
>
>
> int concurrency_hint() const
> {
> return concurrency_hint_;
> }
>
>private:
>
> typedef conditionally_enabled_mutex mutex;
>
>
> typedef conditionally_enabled_event event;
>
>
> typedef scheduler_thread_info thread_info;
>
>
> inline std::size_t do_run_one(mutex::scoped_lock& lock,
> thread_info& this_thread, const boost::system::error_code& ec);
>
>
> inline std::size_t do_wait_one(mutex::scoped_lock& lock,
> thread_info& this_thread, long usec, const boost::system::error_code& ec);
>
>
> inline std::size_t do_poll_one(mutex::scoped_lock& lock,
> thread_info& this_thread, const boost::system::error_code& ec);
>
>
> inline void stop_all_threads(mutex::scoped_lock& lock);
>
>
> inline void wake_one_thread_and_unlock(
> mutex::scoped_lock& lock);
>
>
> struct task_cleanup;
> friend struct task_cleanup;
>
>
> struct work_cleanup;
> friend struct work_cleanup;
>
>
> const bool one_thread_;
>
>
> mutable mutex mutex_;
>
>
> event wakeup_event_;
>
>
> reactor* task_;
>
>
> struct task_operation : operation
> {
> task_operation() : operation(0) {}
> } task_operation_;
>
>
> bool task_interrupted_;
>
>
> atomic_count outstanding_work_;
>
>
> op_queue<operation> op_queue_;
>
>
> bool stopped_;
>
>
> bool shutdown_;
>
>
> const int concurrency_hint_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 210 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/concurrency_hint.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/limits.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/limits.hpp" 3 4
># 1 "/usr/include/boost/limits.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/limits.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactor.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/reactor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/object_pool.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/object_pool.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/object_pool.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Object>
>class object_pool;
>
>class object_pool_access
>{
>public:
> template <typename Object>
> static Object* create()
> {
> return new Object;
> }
>
> template <typename Object, typename Arg>
> static Object* create(Arg arg)
> {
> return new Object(arg);
> }
>
> template <typename Object>
> static void destroy(Object* o)
> {
> delete o;
> }
>
> template <typename Object>
> static Object*& next(Object* o)
> {
> return o->next_;
> }
>
> template <typename Object>
> static Object*& prev(Object* o)
> {
> return o->prev_;
> }
>};
>
>template <typename Object>
>class object_pool
> : private noncopyable
>{
>public:
>
> object_pool()
> : live_list_(0),
> free_list_(0)
> {
> }
>
>
> ~object_pool()
> {
> destroy_list(live_list_);
> destroy_list(free_list_);
> }
>
>
> Object* first()
> {
> return live_list_;
> }
>
>
> Object* alloc()
> {
> Object* o = free_list_;
> if (o)
> free_list_ = object_pool_access::next(free_list_);
> else
> o = object_pool_access::create<Object>();
>
> object_pool_access::next(o) = live_list_;
> object_pool_access::prev(o) = 0;
> if (live_list_)
> object_pool_access::prev(live_list_) = o;
> live_list_ = o;
>
> return o;
> }
>
>
> template <typename Arg>
> Object* alloc(Arg arg)
> {
> Object* o = free_list_;
> if (o)
> free_list_ = object_pool_access::next(free_list_);
> else
> o = object_pool_access::create<Object>(arg);
>
> object_pool_access::next(o) = live_list_;
> object_pool_access::prev(o) = 0;
> if (live_list_)
> object_pool_access::prev(live_list_) = o;
> live_list_ = o;
>
> return o;
> }
>
>
> void free(Object* o)
> {
> if (live_list_ == o)
> live_list_ = object_pool_access::next(o);
>
> if (object_pool_access::prev(o))
> {
> object_pool_access::next(object_pool_access::prev(o))
> = object_pool_access::next(o);
> }
>
> if (object_pool_access::next(o))
> {
> object_pool_access::prev(object_pool_access::next(o))
> = object_pool_access::prev(o);
> }
>
> object_pool_access::next(o) = free_list_;
> object_pool_access::prev(o) = 0;
> free_list_ = o;
> }
>
>private:
>
> void destroy_list(Object* list)
> {
> while (list)
> {
> Object* o = list;
> list = object_pool_access::next(o);
> object_pool_access::destroy(o);
> }
> }
>
>
> Object* live_list_;
>
>
> Object* free_list_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 172 "/usr/include/boost/asio/detail/object_pool.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/reactor_op.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/reactor_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/operation.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/operation.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>typedef scheduler_operation operation;
>
>
>}
>}
>}
># 20 "/usr/include/boost/asio/detail/reactor_op.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/reactor_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactor_op
> : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>
> std::size_t bytes_transferred_;
>
>
>
> enum status { not_done, done, done_and_exhausted };
>
>
> status perform()
> {
> return perform_func_(this);
> }
>
>protected:
> typedef status (*perform_func_type)(reactor_op*);
>
> reactor_op(perform_func_type perform_func, func_type complete_func)
> : operation(complete_func),
> bytes_transferred_(0),
> perform_func_(perform_func)
> {
> }
>
>private:
> perform_func_type perform_func_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 66 "/usr/include/boost/asio/detail/reactor_op.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/select_interrupter.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/select_interrupter.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class eventfd_select_interrupter
>{
>public:
>
> inline eventfd_select_interrupter();
>
>
> inline ~eventfd_select_interrupter();
>
>
> inline void recreate();
>
>
> inline void interrupt();
>
>
> inline bool reset();
>
>
> int read_descriptor() const
> {
> return read_descriptor_;
> }
>
>private:
>
> inline void open_descriptors();
>
>
> inline void close_descriptors();
>
>
>
>
>
> int read_descriptor_;
>
>
>
>
>
> int write_descriptor_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 78 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 3 4
># 1 "/usr/include/sys/stat.h" 1 3 4
># 99 "/usr/include/sys/stat.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/stat.h" 1 3 4
># 46 "/usr/include/bits/stat.h" 3 4
>struct stat
> {
> __dev_t st_dev;
>
>
>
>
> __ino_t st_ino;
>
>
>
>
>
>
>
> __nlink_t st_nlink;
> __mode_t st_mode;
>
> __uid_t st_uid;
> __gid_t st_gid;
>
> int __pad0;
>
> __dev_t st_rdev;
>
>
>
>
> __off_t st_size;
>
>
>
> __blksize_t st_blksize;
>
> __blkcnt_t st_blocks;
># 91 "/usr/include/bits/stat.h" 3 4
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
># 106 "/usr/include/bits/stat.h" 3 4
> __syscall_slong_t __glibc_reserved[3];
># 115 "/usr/include/bits/stat.h" 3 4
> };
>
>
>
>struct stat64
> {
> __dev_t st_dev;
>
> __ino64_t st_ino;
> __nlink_t st_nlink;
> __mode_t st_mode;
>
>
>
>
>
>
> __uid_t st_uid;
> __gid_t st_gid;
>
> int __pad0;
> __dev_t st_rdev;
> __off_t st_size;
>
>
>
>
>
> __blksize_t st_blksize;
> __blkcnt64_t st_blocks;
>
>
>
>
>
>
>
> struct timespec st_atim;
> struct timespec st_mtim;
> struct timespec st_ctim;
># 164 "/usr/include/bits/stat.h" 3 4
> __syscall_slong_t __glibc_reserved[3];
>
>
>
> };
># 102 "/usr/include/sys/stat.h" 2 3 4
># 205 "/usr/include/sys/stat.h" 3 4
>extern int stat (const char *__restrict __file,
> struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
># 224 "/usr/include/sys/stat.h" 3 4
>extern int stat64 (const char *__restrict __file,
> struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
>extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>
>extern int fstatat (int __fd, const char *__restrict __file,
> struct stat *__restrict __buf, int __flag)
> throw () __attribute__ ((__nonnull__ (2, 3)));
># 249 "/usr/include/sys/stat.h" 3 4
>extern int fstatat64 (int __fd, const char *__restrict __file,
> struct stat64 *__restrict __buf, int __flag)
> throw () __attribute__ ((__nonnull__ (2, 3)));
>
>
>
>
>
>
>
>extern int lstat (const char *__restrict __file,
> struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
># 272 "/usr/include/sys/stat.h" 3 4
>extern int lstat64 (const char *__restrict __file,
> struct stat64 *__restrict __buf)
> throw () __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern int chmod (const char *__file, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int lchmod (const char *__file, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int fchmod (int __fd, __mode_t __mode) throw ();
>
>
>
>
>
>extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
> int __flag)
> throw () __attribute__ ((__nonnull__ (2))) ;
>
>
>
>
>
>
>extern __mode_t umask (__mode_t __mask) throw ();
>
>
>
>
>extern __mode_t getumask (void) throw ();
>
>
>
>extern int mkdir (const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>
>extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mknodat (int __fd, const char *__path, __mode_t __mode,
> __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int mkfifo (const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>
>extern int utimensat (int __fd, const char *__path,
> const struct timespec __times[2],
> int __flags)
> throw () __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern int futimens (int __fd, const struct timespec __times[2]) throw ();
># 395 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
> throw () __attribute__ ((__nonnull__ (3)));
>extern int __xstat (int __ver, const char *__filename,
> struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat (int __ver, const char *__filename,
> struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat (int __ver, int __fildes, const char *__filename,
> struct stat *__stat_buf, int __flag)
> throw () __attribute__ ((__nonnull__ (3, 4)));
># 428 "/usr/include/sys/stat.h" 3 4
>extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
> throw () __attribute__ ((__nonnull__ (3)));
>extern int __xstat64 (int __ver, const char *__filename,
> struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __lxstat64 (int __ver, const char *__filename,
> struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
>extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
> struct stat64 *__stat_buf, int __flag)
> throw () __attribute__ ((__nonnull__ (3, 4)));
>
>extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
> __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
>
>extern int __xmknodat (int __ver, int __fd, const char *__path,
> __mode_t __mode, __dev_t *__dev)
> throw () __attribute__ ((__nonnull__ (3, 5)));
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) stat (const char *__path, struct stat *__statbuf) throw ()
>{
> return __xstat (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) lstat (const char *__path, struct stat *__statbuf) throw ()
>{
> return __lxstat (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstat (int __fd, struct stat *__statbuf) throw ()
>{
> return __fxstat (1, __fd, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstatat (int __fd, const char *__filename, struct stat *__statbuf, int __flag) throw ()
>
>{
> return __fxstatat (1, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) mknod (const char *__path, __mode_t __mode, __dev_t __dev) throw ()
>{
> return __xmknod (0, __path, __mode, &__dev);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) mknodat (int __fd, const char *__path, __mode_t __mode, __dev_t __dev) throw ()
>
>{
> return __xmknodat (0, __fd, __path, __mode, &__dev);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) stat64 (const char *__path, struct stat64 *__statbuf) throw ()
>{
> return __xstat64 (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) lstat64 (const char *__path, struct stat64 *__statbuf) throw ()
>{
> return __lxstat64 (1, __path, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstat64 (int __fd, struct stat64 *__statbuf) throw ()
>{
> return __fxstat64 (1, __fd, __statbuf);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) fstatat64 (int __fd, const char *__filename, struct stat64 *__statbuf, int __flag) throw ()
>
>{
> return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
>}
>
>
>
>
>
>
>}
># 24 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
># 1 "/usr/include/fcntl.h" 1 3 4
># 28 "/usr/include/fcntl.h" 3 4
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/fcntl.h" 1 3 4
># 35 "/usr/include/bits/fcntl.h" 3 4
>struct flock
> {
> short int l_type;
> short int l_whence;
>
> __off_t l_start;
> __off_t l_len;
>
>
>
>
> __pid_t l_pid;
> };
>
>
>struct flock64
> {
> short int l_type;
> short int l_whence;
> __off64_t l_start;
> __off64_t l_len;
> __pid_t l_pid;
> };
>
>
>
># 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
># 265 "/usr/include/bits/fcntl-linux.h" 3 4
>enum __pid_type
> {
> F_OWNER_TID = 0,
> F_OWNER_PID,
> F_OWNER_PGRP,
> F_OWNER_GID = F_OWNER_PGRP
> };
>
>
>struct f_owner_ex
> {
> enum __pid_type type;
> __pid_t pid;
> };
># 346 "/usr/include/bits/fcntl-linux.h" 3 4
># 1 "/usr/include/linux/falloc.h" 1 3 4
># 347 "/usr/include/bits/fcntl-linux.h" 2 3 4
>
>
>
>struct file_handle
>{
> unsigned int handle_bytes;
> int handle_type;
>
> unsigned char f_handle[0];
>};
>
>
>
>
>
>extern "C" {
>
>
>
>
>extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
> throw ();
>
>
>
>
>
>
>extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
> unsigned int __flags);
>
>
>
>
>
>
>extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov,
> size_t __count, unsigned int __flags);
>
>
>
>
>
>extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
> __off64_t *__offout, size_t __len,
> unsigned int __flags);
>
>
>
>
>
>extern __ssize_t tee (int __fdin, int __fdout, size_t __len,
> unsigned int __flags);
>
>
>
>
>
>
>extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
># 417 "/usr/include/bits/fcntl-linux.h" 3 4
>extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
> __off64_t __len);
>
>
>
>
>extern int name_to_handle_at (int __dfd, const char *__name,
> struct file_handle *__handle, int *__mnt_id,
> int __flags) throw ();
>
>
>
>
>
>extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
> int __flags);
>
>
>
>}
># 61 "/usr/include/bits/fcntl.h" 2 3 4
># 36 "/usr/include/fcntl.h" 2 3 4
># 78 "/usr/include/fcntl.h" 3 4
># 1 "/usr/include/bits/stat.h" 1 3 4
># 79 "/usr/include/fcntl.h" 2 3 4
># 170 "/usr/include/fcntl.h" 3 4
>extern int fcntl (int __fd, int __cmd, ...);
># 180 "/usr/include/fcntl.h" 3 4
>extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 190 "/usr/include/fcntl.h" 3 4
>extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
># 204 "/usr/include/fcntl.h" 3 4
>extern int openat (int __fd, const char *__file, int __oflag, ...)
> __attribute__ ((__nonnull__ (2)));
># 215 "/usr/include/fcntl.h" 3 4
>extern int openat64 (int __fd, const char *__file, int __oflag, ...)
> __attribute__ ((__nonnull__ (2)));
># 226 "/usr/include/fcntl.h" 3 4
>extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 236 "/usr/include/fcntl.h" 3 4
>extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
># 272 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
> int __advise) throw ();
># 284 "/usr/include/fcntl.h" 3 4
>extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
> int __advise) throw ();
># 294 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
># 305 "/usr/include/fcntl.h" 3 4
>extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
># 316 "/usr/include/fcntl.h" 3 4
>}
># 26 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
>
>
># 1 "/usr/include/sys/eventfd.h" 1 3 4
># 24 "/usr/include/sys/eventfd.h" 3 4
># 1 "/usr/include/bits/eventfd.h" 1 3 4
># 23 "/usr/include/bits/eventfd.h" 3 4
>enum
> {
> EFD_SEMAPHORE = 00000001,
>
> EFD_CLOEXEC = 02000000,
>
> EFD_NONBLOCK = 00004000
>
> };
># 25 "/usr/include/sys/eventfd.h" 2 3 4
>
>
>typedef uint64_t eventfd_t;
>
>
>extern "C" {
>
>
>
>extern int eventfd (unsigned int __count, int __flags) throw ();
>
>
>extern int eventfd_read (int __fd, eventfd_t *__value);
>
>
>extern int eventfd_write (int __fd, eventfd_t __value);
>
>}
># 30 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/cstdint.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/cstdint.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>using std::int16_t;
>using std::int_least16_t;
>using std::uint16_t;
>using std::uint_least16_t;
>using std::int32_t;
>using std::int_least32_t;
>using std::uint32_t;
>using std::uint_least32_t;
>using std::int64_t;
>using std::int_least64_t;
>using std::uint64_t;
>using std::uint_least64_t;
>using std::uintmax_t;
># 59 "/usr/include/boost/asio/detail/cstdint.hpp" 3 4
>}
>}
># 32 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 1 3 4
># 33 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 37 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>eventfd_select_interrupter::eventfd_select_interrupter()
>{
> open_descriptors();
>}
>
>void eventfd_select_interrupter::open_descriptors()
>{
># 58 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 3 4
> write_descriptor_ = read_descriptor_ =
> ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
>
>
>
>
> if (read_descriptor_ == -1 && (*__errno_location ()) == 22)
> {
> write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
> if (read_descriptor_ != -1)
> {
> ::fcntl(read_descriptor_, 4, 04000);
> ::fcntl(read_descriptor_, 2, 1);
> }
> }
>
>
> if (read_descriptor_ == -1)
> {
> int pipe_fds[2];
> if (pipe(pipe_fds) == 0)
> {
> read_descriptor_ = pipe_fds[0];
> ::fcntl(read_descriptor_, 4, 04000);
> ::fcntl(read_descriptor_, 2, 1);
> write_descriptor_ = pipe_fds[1];
> ::fcntl(write_descriptor_, 4, 04000);
> ::fcntl(write_descriptor_, 2, 1);
> }
> else
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "eventfd_select_interrupter");
> }
> }
>}
>
>eventfd_select_interrupter::~eventfd_select_interrupter()
>{
> close_descriptors();
>}
>
>void eventfd_select_interrupter::close_descriptors()
>{
> if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
> ::close(write_descriptor_);
> if (read_descriptor_ != -1)
> ::close(read_descriptor_);
>}
>
>void eventfd_select_interrupter::recreate()
>{
> close_descriptors();
>
> write_descriptor_ = -1;
> read_descriptor_ = -1;
>
> open_descriptors();
>}
>
>void eventfd_select_interrupter::interrupt()
>{
> uint64_t counter(1UL);
> int result = ::write(write_descriptor_, &counter, sizeof(uint64_t));
> (void)result;
>}
>
>bool eventfd_select_interrupter::reset()
>{
> if (write_descriptor_ == read_descriptor_)
> {
> for (;;)
> {
>
> uint64_t counter(0);
> (*__errno_location ()) = 0;
> int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
> if (bytes_read < 0 && (*__errno_location ()) == 4)
> continue;
> bool was_interrupted = (bytes_read > 0);
> return was_interrupted;
> }
> }
> else
> {
> for (;;)
> {
>
> char data[1024];
> int bytes_read = ::read(read_descriptor_, data, sizeof(data));
> if (bytes_read < 0 && (*__errno_location ()) == 4)
> continue;
> bool was_interrupted = (bytes_read > 0);
> while (bytes_read == sizeof(data))
> bytes_read = ::read(read_descriptor_, data, sizeof(data));
> return was_interrupted;
> }
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 164 "/usr/include/boost/asio/detail/impl/eventfd_select_interrupter.ipp" 2 3 4
># 81 "/usr/include/boost/asio/detail/eventfd_select_interrupter.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/select_interrupter.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>typedef eventfd_select_interrupter select_interrupter;
>
>
>
>
>}
>}
>}
># 29 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/socket_types.hpp" 1 3 4
># 59 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
># 1 "/usr/include/sys/ioctl.h" 1 3 4
># 23 "/usr/include/sys/ioctl.h" 3 4
>extern "C" {
>
>
># 1 "/usr/include/bits/ioctls.h" 1 3 4
># 23 "/usr/include/bits/ioctls.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctls.h" 1 3 4
>
>
>
>
># 1 "/usr/include/linux/ioctl.h" 1 3 4
>
>
>
>
># 1 "/usr/include/asm/ioctl.h" 1 3 4
># 1 "/usr/include/asm-generic/ioctl.h" 1 3 4
># 1 "/usr/include/asm/ioctl.h" 2 3 4
># 6 "/usr/include/linux/ioctl.h" 2 3 4
># 6 "/usr/include/asm-generic/ioctls.h" 2 3 4
># 1 "/usr/include/asm/ioctls.h" 2 3 4
># 24 "/usr/include/bits/ioctls.h" 2 3 4
># 27 "/usr/include/sys/ioctl.h" 2 3 4
>
>
># 1 "/usr/include/bits/ioctl-types.h" 1 3 4
># 24 "/usr/include/bits/ioctl-types.h" 3 4
># 1 "/usr/include/asm/ioctls.h" 1 3 4
># 25 "/usr/include/bits/ioctl-types.h" 2 3 4
>
>
>struct winsize
> {
> unsigned short int ws_row;
> unsigned short int ws_col;
> unsigned short int ws_xpixel;
> unsigned short int ws_ypixel;
> };
>
>
>struct termio
> {
> unsigned short int c_iflag;
> unsigned short int c_oflag;
> unsigned short int c_cflag;
> unsigned short int c_lflag;
> unsigned char c_line;
> unsigned char c_cc[8];
>};
># 30 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 37 "/usr/include/sys/ioctl.h" 2 3 4
>
>
>
>
>extern int ioctl (int __fd, unsigned long int __request, ...) throw ();
>
>}
># 60 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/poll.h" 1 3 4
># 1 "/usr/include/sys/poll.h" 1 3 4
># 25 "/usr/include/sys/poll.h" 3 4
># 1 "/usr/include/bits/poll.h" 1 3 4
># 26 "/usr/include/sys/poll.h" 2 3 4
>
>
>
>
>
>
>
>typedef unsigned long int nfds_t;
>
>
>struct pollfd
> {
> int fd;
> short int events;
> short int revents;
> };
>
>
>extern "C" {
># 54 "/usr/include/sys/poll.h" 3 4
>extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);
># 63 "/usr/include/sys/poll.h" 3 4
>extern int ppoll (struct pollfd *__fds, nfds_t __nfds,
> const struct timespec *__timeout,
> const __sigset_t *__ss);
>
>
>}
># 1 "/usr/include/poll.h" 2 3 4
># 65 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 78 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
># 1 "/usr/include/sys/uio.h" 1 3 4
># 31 "/usr/include/sys/uio.h" 3 4
>extern "C" {
># 41 "/usr/include/sys/uio.h" 3 4
>extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
> ;
># 52 "/usr/include/sys/uio.h" 3 4
>extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
> ;
># 67 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
> __off_t __offset) ;
># 79 "/usr/include/sys/uio.h" 3 4
>extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
> __off_t __offset) ;
># 106 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
> __off64_t __offset) ;
># 118 "/usr/include/sys/uio.h" 3 4
>extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
> __off64_t __offset) ;
>
>
>
>
>
>
>
>extern ssize_t preadv2 (int __fp, const struct iovec *__iovec, int __count,
> __off_t __offset, int ___flags) ;
>
>
>extern ssize_t pwritev2 (int __fd, const struct iovec *__iodev, int __count,
> __off_t __offset, int __flags) ;
># 152 "/usr/include/sys/uio.h" 3 4
>extern ssize_t preadv64v2 (int __fp, const struct iovec *__iovec,
> int __count, __off64_t __offset,
> int ___flags) ;
>
>
>extern ssize_t pwritev64v2 (int __fd, const struct iovec *__iodev,
> int __count, __off64_t __offset,
> int __flags) ;
>
>
>
>}
>
>
>
>
># 1 "/usr/include/bits/uio-ext.h" 1 3 4
># 26 "/usr/include/bits/uio-ext.h" 3 4
>extern "C" {
>
>
>extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
> unsigned long int __liovcnt,
> const struct iovec *__rvec,
> unsigned long int __riovcnt,
> unsigned long int __flags)
> throw ();
>
>
>extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
> unsigned long int __liovcnt,
> const struct iovec *__rvec,
> unsigned long int __riovcnt,
> unsigned long int __flags)
> throw ();
># 51 "/usr/include/bits/uio-ext.h" 3 4
>}
># 169 "/usr/include/sys/uio.h" 2 3 4
># 79 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 1 "/usr/include/sys/un.h" 1 3 4
># 26 "/usr/include/sys/un.h" 3 4
>extern "C" {
>
>
>struct sockaddr_un
> {
> sa_family_t sun_family;
> char sun_path[108];
> };
># 44 "/usr/include/sys/un.h" 3 4
>}
># 80 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>
># 1 "/usr/include/netinet/tcp.h" 1 3 4
># 82 "/usr/include/netinet/tcp.h" 3 4
>typedef uint32_t tcp_seq;
>
>
>
>
>struct tcphdr
> {
> __extension__ union
> {
> struct
> {
> uint16_t th_sport;
> uint16_t th_dport;
> tcp_seq th_seq;
> tcp_seq th_ack;
>
> uint8_t th_x2:4;
> uint8_t th_off:4;
>
>
>
>
>
> uint8_t th_flags;
>
>
>
>
>
>
> uint16_t th_win;
> uint16_t th_sum;
> uint16_t th_urp;
> };
> struct
> {
> uint16_t source;
> uint16_t dest;
> uint32_t seq;
> uint32_t ack_seq;
>
> uint16_t res1:4;
> uint16_t doff:4;
> uint16_t fin:1;
> uint16_t syn:1;
> uint16_t rst:1;
> uint16_t psh:1;
> uint16_t ack:1;
> uint16_t urg:1;
> uint16_t res2:2;
># 145 "/usr/include/netinet/tcp.h" 3 4
> uint16_t window;
> uint16_t check;
> uint16_t urg_ptr;
> };
> };
>};
>
>enum
>{
> TCP_ESTABLISHED = 1,
> TCP_SYN_SENT,
> TCP_SYN_RECV,
> TCP_FIN_WAIT1,
> TCP_FIN_WAIT2,
> TCP_TIME_WAIT,
> TCP_CLOSE,
> TCP_CLOSE_WAIT,
> TCP_LAST_ACK,
> TCP_LISTEN,
> TCP_CLOSING
>};
># 206 "/usr/include/netinet/tcp.h" 3 4
>enum tcp_ca_state
>{
> TCP_CA_Open = 0,
> TCP_CA_Disorder = 1,
> TCP_CA_CWR = 2,
> TCP_CA_Recovery = 3,
> TCP_CA_Loss = 4
>};
>
>struct tcp_info
>{
> uint8_t tcpi_state;
> uint8_t tcpi_ca_state;
> uint8_t tcpi_retransmits;
> uint8_t tcpi_probes;
> uint8_t tcpi_backoff;
> uint8_t tcpi_options;
> uint8_t tcpi_snd_wscale : 4, tcpi_rcv_wscale : 4;
>
> uint32_t tcpi_rto;
> uint32_t tcpi_ato;
> uint32_t tcpi_snd_mss;
> uint32_t tcpi_rcv_mss;
>
> uint32_t tcpi_unacked;
> uint32_t tcpi_sacked;
> uint32_t tcpi_lost;
> uint32_t tcpi_retrans;
> uint32_t tcpi_fackets;
>
>
> uint32_t tcpi_last_data_sent;
> uint32_t tcpi_last_ack_sent;
> uint32_t tcpi_last_data_recv;
> uint32_t tcpi_last_ack_recv;
>
>
> uint32_t tcpi_pmtu;
> uint32_t tcpi_rcv_ssthresh;
> uint32_t tcpi_rtt;
> uint32_t tcpi_rttvar;
> uint32_t tcpi_snd_ssthresh;
> uint32_t tcpi_snd_cwnd;
> uint32_t tcpi_advmss;
> uint32_t tcpi_reordering;
>
> uint32_t tcpi_rcv_rtt;
> uint32_t tcpi_rcv_space;
>
> uint32_t tcpi_total_retrans;
>};
># 265 "/usr/include/netinet/tcp.h" 3 4
>struct tcp_md5sig
>{
> struct sockaddr_storage tcpm_addr;
> uint8_t tcpm_flags;
> uint8_t tcpm_prefixlen;
> uint16_t tcpm_keylen;
> uint32_t __tcpm_pad;
> uint8_t tcpm_key[80];
>};
>
>
>struct tcp_repair_opt
>{
> uint32_t opt_code;
> uint32_t opt_val;
>};
>
>
>enum
>{
> TCP_NO_QUEUE,
> TCP_RECV_QUEUE,
> TCP_SEND_QUEUE,
> TCP_QUEUES_NR,
>};
># 308 "/usr/include/netinet/tcp.h" 3 4
>struct tcp_cookie_transactions
>{
> uint16_t tcpct_flags;
> uint8_t __tcpct_pad1;
> uint8_t tcpct_cookie_desired;
> uint16_t tcpct_s_data_desired;
> uint16_t tcpct_used;
> uint8_t tcpct_value[536U];
>};
>
>
>struct tcp_repair_window
>{
> uint32_t snd_wl1;
> uint32_t snd_wnd;
> uint32_t max_window;
> uint32_t rcv_wnd;
> uint32_t rcv_wup;
>};
># 83 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
># 1 "/usr/include/arpa/inet.h" 1 3 4
># 30 "/usr/include/arpa/inet.h" 3 4
>extern "C" {
>
>
>
>extern in_addr_t inet_addr (const char *__cp) throw ();
>
>
>extern in_addr_t inet_lnaof (struct in_addr __in) throw ();
>
>
>
>extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
> throw ();
>
>
>extern in_addr_t inet_netof (struct in_addr __in) throw ();
>
>
>
>extern in_addr_t inet_network (const char *__cp) throw ();
>
>
>
>extern char *inet_ntoa (struct in_addr __in) throw ();
>
>
>
>
>extern int inet_pton (int __af, const char *__restrict __cp,
> void *__restrict __buf) throw ();
>
>
>
>
>extern const char *inet_ntop (int __af, const void *__restrict __cp,
> char *__restrict __buf, socklen_t __len)
> throw ();
>
>
>
>
>
>
>extern int inet_aton (const char *__cp, struct in_addr *__inp) throw ();
>
>
>
>extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) throw ();
>
>
>
>
>extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
> char *__buf, size_t __len) throw ();
>
>
>
>
>extern int inet_net_pton (int __af, const char *__cp,
> void *__buf, size_t __len) throw ();
>
>
>
>
>extern unsigned int inet_nsap_addr (const char *__cp,
> unsigned char *__buf, int __len) throw ();
>
>
>
>extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
> char *__buf) throw ();
>
>
>}
># 85 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
># 1 "/usr/include/net/if.h" 1 3 4
># 33 "/usr/include/net/if.h" 3 4
>struct if_nameindex
> {
> unsigned int if_index;
> char *if_name;
> };
>
>
>
>
>enum
> {
> IFF_UP = 0x1,
>
> IFF_BROADCAST = 0x2,
>
> IFF_DEBUG = 0x4,
>
> IFF_LOOPBACK = 0x8,
>
> IFF_POINTOPOINT = 0x10,
>
> IFF_NOTRAILERS = 0x20,
>
> IFF_RUNNING = 0x40,
>
> IFF_NOARP = 0x80,
>
> IFF_PROMISC = 0x100,
>
>
>
> IFF_ALLMULTI = 0x200,
>
>
> IFF_MASTER = 0x400,
>
> IFF_SLAVE = 0x800,
>
>
> IFF_MULTICAST = 0x1000,
>
>
> IFF_PORTSEL = 0x2000,
>
> IFF_AUTOMEDIA = 0x4000,
>
> IFF_DYNAMIC = 0x8000
>
> };
>
>
>
>
>
>
>struct ifaddr
> {
> struct sockaddr ifa_addr;
> union
> {
> struct sockaddr ifu_broadaddr;
> struct sockaddr ifu_dstaddr;
> } ifa_ifu;
> struct iface *ifa_ifp;
> struct ifaddr *ifa_next;
> };
># 111 "/usr/include/net/if.h" 3 4
>struct ifmap
> {
> unsigned long int mem_start;
> unsigned long int mem_end;
> unsigned short int base_addr;
> unsigned char irq;
> unsigned char dma;
> unsigned char port;
>
> };
>
>
>
>
>
>struct ifreq
> {
>
>
> union
> {
> char ifrn_name[16];
> } ifr_ifrn;
>
> union
> {
> struct sockaddr ifru_addr;
> struct sockaddr ifru_dstaddr;
> struct sockaddr ifru_broadaddr;
> struct sockaddr ifru_netmask;
> struct sockaddr ifru_hwaddr;
> short int ifru_flags;
> int ifru_ivalue;
> int ifru_mtu;
> struct ifmap ifru_map;
> char ifru_slave[16];
> char ifru_newname[16];
> __caddr_t ifru_data;
> } ifr_ifru;
> };
># 176 "/usr/include/net/if.h" 3 4
>struct ifconf
> {
> int ifc_len;
> union
> {
> __caddr_t ifcu_buf;
> struct ifreq *ifcu_req;
> } ifc_ifcu;
> };
>
>
>
>
>
>extern "C" {
>
>
>extern unsigned int if_nametoindex (const char *__ifname) throw ();
>extern char *if_indextoname (unsigned int __ifindex, char *__ifname) throw ();
>
>
>extern struct if_nameindex *if_nameindex (void) throw ();
>
>
>extern void if_freenameindex (struct if_nameindex *__ptr) throw ();
>
>}
># 87 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 1 3 4
># 88 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 95 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
># 289 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
>typedef int socket_type;
>const int invalid_socket = -1;
>const int socket_error_retval = -1;
>const int max_addr_v4_str_len = 16;
>
>const int max_addr_v6_str_len = 46 + 1 + 16;
>
>
>
>typedef sockaddr socket_addr_type;
>typedef in_addr in4_addr_type;
># 308 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
>typedef ip_mreq in4_mreq_type;
>
>typedef sockaddr_in sockaddr_in4_type;
>typedef in6_addr in6_addr_type;
>typedef ipv6_mreq in6_mreq_type;
>typedef sockaddr_in6 sockaddr_in6_type;
>typedef sockaddr_storage sockaddr_storage_type;
>typedef sockaddr_un sockaddr_un_type;
>typedef addrinfo addrinfo_type;
>typedef ::linger linger_type;
>typedef int ioctl_arg_type;
>typedef uint32_t u_long_type;
>typedef uint16_t u_short_type;
>
>typedef ssize_t signed_size_type;
># 402 "/usr/include/boost/asio/detail/socket_types.hpp" 3 4
>const int max_iov_len = 1024;
>
>
>
>
>
>const int custom_socket_option_level = 0xA5100000;
>const int enable_connection_aborted_option = 1;
>const int always_fail_option = 2;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 417 "/usr/include/boost/asio/detail/socket_types.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class timer_queue_base
> : private noncopyable
>{
>public:
>
> timer_queue_base() : next_(0) {}
>
>
> virtual ~timer_queue_base() {}
>
>
> virtual bool empty() const = 0;
>
>
> virtual long wait_duration_msec(long max_duration) const = 0;
>
>
> virtual long wait_duration_usec(long max_duration) const = 0;
>
>
> virtual void get_ready_timers(op_queue<operation>& ops) = 0;
>
>
> virtual void get_all_timers(op_queue<operation>& ops) = 0;
>
>private:
> friend class timer_queue_set;
>
>
> timer_queue_base* next_;
>};
>
>template <typename Time_Traits>
>class timer_queue;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 69 "/usr/include/boost/asio/detail/timer_queue_base.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class timer_queue_set
>{
>public:
>
> inline timer_queue_set();
>
>
> inline void insert(timer_queue_base* q);
>
>
> inline void erase(timer_queue_base* q);
>
>
> inline bool all_empty() const;
>
>
> inline long wait_duration_msec(long max_duration) const;
>
>
> inline long wait_duration_usec(long max_duration) const;
>
>
> inline void get_ready_timers(op_queue<operation>& ops);
>
>
> inline void get_all_timers(op_queue<operation>& ops);
>
>private:
> timer_queue_base* first_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 63 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>timer_queue_set::timer_queue_set()
> : first_(0)
>{
>}
>
>void timer_queue_set::insert(timer_queue_base* q)
>{
> q->next_ = first_;
> first_ = q;
>}
>
>void timer_queue_set::erase(timer_queue_base* q)
>{
> if (first_)
> {
> if (q == first_)
> {
> first_ = q->next_;
> q->next_ = 0;
> return;
> }
>
> for (timer_queue_base* p = first_; p->next_; p = p->next_)
> {
> if (p->next_ == q)
> {
> p->next_ = q->next_;
> q->next_ = 0;
> return;
> }
> }
> }
>}
>
>bool timer_queue_set::all_empty() const
>{
> for (timer_queue_base* p = first_; p; p = p->next_)
> if (!p->empty())
> return false;
> return true;
>}
>
>long timer_queue_set::wait_duration_msec(long max_duration) const
>{
> long min_duration = max_duration;
> for (timer_queue_base* p = first_; p; p = p->next_)
> min_duration = p->wait_duration_msec(min_duration);
> return min_duration;
>}
>
>long timer_queue_set::wait_duration_usec(long max_duration) const
>{
> long min_duration = max_duration;
> for (timer_queue_base* p = first_; p; p = p->next_)
> min_duration = p->wait_duration_usec(min_duration);
> return min_duration;
>}
>
>void timer_queue_set::get_ready_timers(op_queue<operation>& ops)
>{
> for (timer_queue_base* p = first_; p; p = p->next_)
> p->get_ready_timers(ops);
>}
>
>void timer_queue_set::get_all_timers(op_queue<operation>& ops)
>{
> for (timer_queue_base* p = first_; p; p = p->next_)
> p->get_all_timers(ops);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 102 "/usr/include/boost/asio/detail/impl/timer_queue_set.ipp" 2 3 4
># 66 "/usr/include/boost/asio/detail/timer_queue_set.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/wait_op.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/wait_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/wait_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class wait_op
> : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>protected:
> wait_op(func_type func)
> : operation(func)
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 46 "/usr/include/boost/asio/detail/wait_op.hpp" 2 3 4
># 33 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 36 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class epoll_reactor
> : public execution_context_service_base<epoll_reactor>
>{
>private:
>
> typedef conditionally_enabled_mutex mutex;
>
>public:
> enum op_types { read_op = 0, write_op = 1,
> connect_op = 1, except_op = 2, max_ops = 3 };
>
>
> class descriptor_state : operation
> {
> friend class epoll_reactor;
> friend class object_pool_access;
>
> descriptor_state* next_;
> descriptor_state* prev_;
>
> mutex mutex_;
> epoll_reactor* reactor_;
> int descriptor_;
> uint32_t registered_events_;
> op_queue<reactor_op> op_queue_[max_ops];
> bool try_speculative_[max_ops];
> bool shutdown_;
>
> inline descriptor_state(bool locking);
> void set_ready_events(uint32_t events) { task_result_ = events; }
> void add_ready_events(uint32_t events) { task_result_ |= events; }
> inline operation* perform_io(uint32_t events);
> inline static void do_complete(
> void* owner, operation* base,
> const boost::system::error_code& ec, std::size_t bytes_transferred);
> };
>
>
> typedef descriptor_state* per_descriptor_data;
>
>
> inline epoll_reactor(boost::asio::execution_context& ctx);
>
>
> inline ~epoll_reactor();
>
>
> inline void shutdown();
>
>
> inline void notify_fork(
> boost::asio::execution_context::fork_event fork_ev);
>
>
> inline void init_task();
>
>
>
> inline int register_descriptor(socket_type descriptor,
> per_descriptor_data& descriptor_data);
>
>
>
> inline int register_internal_descriptor(
> int op_type, socket_type descriptor,
> per_descriptor_data& descriptor_data, reactor_op* op);
>
>
> inline void move_descriptor(socket_type descriptor,
> per_descriptor_data& target_descriptor_data,
> per_descriptor_data& source_descriptor_data);
>
>
> void post_immediate_completion(reactor_op* op, bool is_continuation)
> {
> scheduler_.post_immediate_completion(op, is_continuation);
> }
>
>
>
> inline void start_op(int op_type, socket_type descriptor,
> per_descriptor_data& descriptor_data, reactor_op* op,
> bool is_continuation, bool allow_speculative);
>
>
>
>
> inline void cancel_ops(socket_type descriptor,
> per_descriptor_data& descriptor_data);
>
>
>
>
> inline void deregister_descriptor(socket_type descriptor,
> per_descriptor_data& descriptor_data, bool closing);
>
>
>
>
> inline void deregister_internal_descriptor(
> socket_type descriptor, per_descriptor_data& descriptor_data);
>
>
>
> inline void cleanup_descriptor_data(
> per_descriptor_data& descriptor_data);
>
>
> template <typename Time_Traits>
> void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
>
>
> template <typename Time_Traits>
> void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
>
>
>
> template <typename Time_Traits>
> void schedule_timer(timer_queue<Time_Traits>& queue,
> const typename Time_Traits::time_type& time,
> typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
>
>
>
> template <typename Time_Traits>
> std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
> typename timer_queue<Time_Traits>::per_timer_data& timer,
> std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
>
>
> template <typename Time_Traits>
> void move_timer(timer_queue<Time_Traits>& queue,
> typename timer_queue<Time_Traits>::per_timer_data& target,
> typename timer_queue<Time_Traits>::per_timer_data& source);
>
>
> inline void run(long usec, op_queue<operation>& ops);
>
>
> inline void interrupt();
>
>private:
>
> enum { epoll_size = 20000 };
>
>
>
> inline static int do_epoll_create();
>
>
> inline static int do_timerfd_create();
>
>
> inline descriptor_state* allocate_descriptor_state();
>
>
> inline void free_descriptor_state(descriptor_state* s);
>
>
> inline void do_add_timer_queue(timer_queue_base& queue);
>
>
> inline void do_remove_timer_queue(timer_queue_base& queue);
>
>
> inline void update_timeout();
>
>
>
>
> inline int get_timeout(int msec);
>
>
>
>
> inline int get_timeout(itimerspec& ts);
>
>
>
> scheduler& scheduler_;
>
>
> mutex mutex_;
>
>
> select_interrupter interrupter_;
>
>
> int epoll_fd_;
>
>
> int timer_fd_;
>
>
> timer_queue_set timer_queues_;
>
>
> bool shutdown_;
>
>
> mutex registered_descriptors_mutex_;
>
>
> object_pool<descriptor_state> registered_descriptors_;
>
>
> struct perform_io_cleanup_on_block_exit;
> friend struct perform_io_cleanup_on_block_exit;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 256 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
>{
> do_add_timer_queue(queue);
>}
>
>template <typename Time_Traits>
>void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
>{
> do_remove_timer_queue(queue);
>}
>
>template <typename Time_Traits>
>void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
> const typename Time_Traits::time_type& time,
> typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
>{
> mutex::scoped_lock lock(mutex_);
>
> if (shutdown_)
> {
> scheduler_.post_immediate_completion(op, false);
> return;
> }
>
> bool earliest = queue.enqueue_timer(time, timer, op);
> scheduler_.work_started();
> if (earliest)
> update_timeout();
>}
>
>template <typename Time_Traits>
>std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
> typename timer_queue<Time_Traits>::per_timer_data& timer,
> std::size_t max_cancelled)
>{
> mutex::scoped_lock lock(mutex_);
> op_queue<operation> ops;
> std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
> lock.unlock();
> scheduler_.post_deferred_completions(ops);
> return n;
>}
>
>template <typename Time_Traits>
>void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue,
> typename timer_queue<Time_Traits>::per_timer_data& target,
> typename timer_queue<Time_Traits>::per_timer_data& source)
>{
> mutex::scoped_lock lock(mutex_);
> op_queue<operation> ops;
> queue.cancel_timer(target, ops);
> queue.move_timer(target, source);
> lock.unlock();
> scheduler_.post_deferred_completions(ops);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 88 "/usr/include/boost/asio/detail/impl/epoll_reactor.hpp" 2 3 4
># 258 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 3 4
># 1 "/usr/include/sys/epoll.h" 1 3 4
># 27 "/usr/include/sys/epoll.h" 3 4
># 1 "/usr/include/bits/epoll.h" 1 3 4
># 23 "/usr/include/bits/epoll.h" 3 4
>enum
> {
> EPOLL_CLOEXEC = 02000000
>
> };
># 28 "/usr/include/sys/epoll.h" 2 3 4
>
>
>
>
>
>
>enum EPOLL_EVENTS
> {
> EPOLLIN = 0x001,
>
> EPOLLPRI = 0x002,
>
> EPOLLOUT = 0x004,
>
> EPOLLRDNORM = 0x040,
>
> EPOLLRDBAND = 0x080,
>
> EPOLLWRNORM = 0x100,
>
> EPOLLWRBAND = 0x200,
>
> EPOLLMSG = 0x400,
>
> EPOLLERR = 0x008,
>
> EPOLLHUP = 0x010,
>
> EPOLLRDHUP = 0x2000,
>
> EPOLLEXCLUSIVE = 1u << 28,
>
> EPOLLWAKEUP = 1u << 29,
>
> EPOLLONESHOT = 1u << 30,
>
> EPOLLET = 1u << 31
>
> };
># 75 "/usr/include/sys/epoll.h" 3 4
>typedef union epoll_data
>{
> void *ptr;
> int fd;
> uint32_t u32;
> uint64_t u64;
>} epoll_data_t;
>
>struct epoll_event
>{
> uint32_t events;
> epoll_data_t data;
>} __attribute__ ((__packed__));
>
>
>extern "C" {
>
>
>
>
>
>extern int epoll_create (int __size) throw ();
>
>
>
>extern int epoll_create1 (int __flags) throw ();
># 109 "/usr/include/sys/epoll.h" 3 4
>extern int epoll_ctl (int __epfd, int __op, int __fd,
> struct epoll_event *__event) throw ();
># 123 "/usr/include/sys/epoll.h" 3 4
>extern int epoll_wait (int __epfd, struct epoll_event *__events,
> int __maxevents, int __timeout);
>
>
>
>
>
>
>
>extern int epoll_pwait (int __epfd, struct epoll_event *__events,
> int __maxevents, int __timeout,
> const __sigset_t *__ss);
>
>}
># 24 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
>
>
>
>
># 1 "/usr/include/sys/timerfd.h" 1 3 4
># 25 "/usr/include/sys/timerfd.h" 3 4
># 1 "/usr/include/bits/timerfd.h" 1 3 4
># 23 "/usr/include/bits/timerfd.h" 3 4
>enum
> {
> TFD_CLOEXEC = 02000000,
>
> TFD_NONBLOCK = 00004000
>
> };
># 26 "/usr/include/sys/timerfd.h" 2 3 4
>
>
>
>enum
> {
> TFD_TIMER_ABSTIME = 1 << 0,
>
> TFD_TIMER_CANCEL_ON_SET = 1 << 1
>
> };
>
>
>extern "C" {
>
>
>extern int timerfd_create (__clockid_t __clock_id, int __flags) throw ();
>
>
>
>
>extern int timerfd_settime (int __ufd, int __flags,
> const struct itimerspec *__utmr,
> struct itimerspec *__otmr) throw ();
>
>
>extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) throw ();
>
>}
># 30 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 33 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>epoll_reactor::epoll_reactor(boost::asio::execution_context& ctx)
> : execution_context_service_base<epoll_reactor>(ctx),
> scheduler_(use_service<scheduler>(ctx)),
> mutex_((((static_cast<unsigned>(scheduler_.concurrency_hint()) & (0xFFFF0000u | 0x2u)) ^ 0xA5100000u) != 0)
> ),
> interrupter_(),
> epoll_fd_(do_epoll_create()),
> timer_fd_(do_timerfd_create()),
> shutdown_(false),
> registered_descriptors_mutex_(mutex_.enabled())
>{
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLET;
> ev.data.ptr = &interrupter_;
> epoll_ctl(epoll_fd_, 1, interrupter_.read_descriptor(), &ev);
> interrupter_.interrupt();
>
>
> if (timer_fd_ != -1)
> {
> ev.events = EPOLLIN | EPOLLERR;
> ev.data.ptr = &timer_fd_;
> epoll_ctl(epoll_fd_, 1, timer_fd_, &ev);
> }
>}
>
>epoll_reactor::~epoll_reactor()
>{
> if (epoll_fd_ != -1)
> close(epoll_fd_);
> if (timer_fd_ != -1)
> close(timer_fd_);
>}
>
>void epoll_reactor::shutdown()
>{
> mutex::scoped_lock lock(mutex_);
> shutdown_ = true;
> lock.unlock();
>
> op_queue<operation> ops;
>
> while (descriptor_state* state = registered_descriptors_.first())
> {
> for (int i = 0; i < max_ops; ++i)
> ops.push(state->op_queue_[i]);
> state->shutdown_ = true;
> registered_descriptors_.free(state);
> }
>
> timer_queues_.get_all_timers(ops);
>
> scheduler_.abandon_operations(ops);
>}
>
>void epoll_reactor::notify_fork(
> boost::asio::execution_context::fork_event fork_ev)
>{
> if (fork_ev == boost::asio::execution_context::fork_child)
> {
> if (epoll_fd_ != -1)
> ::close(epoll_fd_);
> epoll_fd_ = -1;
> epoll_fd_ = do_epoll_create();
>
> if (timer_fd_ != -1)
> ::close(timer_fd_);
> timer_fd_ = -1;
> timer_fd_ = do_timerfd_create();
>
> interrupter_.recreate();
>
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLET;
> ev.data.ptr = &interrupter_;
> epoll_ctl(epoll_fd_, 1, interrupter_.read_descriptor(), &ev);
> interrupter_.interrupt();
>
>
> if (timer_fd_ != -1)
> {
> ev.events = EPOLLIN | EPOLLERR;
> ev.data.ptr = &timer_fd_;
> epoll_ctl(epoll_fd_, 1, timer_fd_, &ev);
> }
>
> update_timeout();
>
>
> mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
> for (descriptor_state* state = registered_descriptors_.first();
> state != 0; state = state->next_)
> {
> ev.events = state->registered_events_;
> ev.data.ptr = state;
> int result = epoll_ctl(epoll_fd_, 1, state->descriptor_, &ev);
> if (result != 0)
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "epoll re-registration");
> }
> }
> }
>}
>
>void epoll_reactor::init_task()
>{
> scheduler_.init_task();
>}
>
>int epoll_reactor::register_descriptor(socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data)
>{
> descriptor_data = allocate_descriptor_state();
>
> (void)0
>
> ;
>
> {
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> descriptor_data->reactor_ = this;
> descriptor_data->descriptor_ = descriptor;
> descriptor_data->shutdown_ = false;
> for (int i = 0; i < max_ops; ++i)
> descriptor_data->try_speculative_[i] = true;
> }
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
> descriptor_data->registered_events_ = ev.events;
> ev.data.ptr = descriptor_data;
> int result = epoll_ctl(epoll_fd_, 1, descriptor, &ev);
> if (result != 0)
> {
> if ((*__errno_location ()) == 1)
> {
>
>
>
>
> descriptor_data->registered_events_ = 0;
> return 0;
> }
> return (*__errno_location ());
> }
>
> return 0;
>}
>
>int epoll_reactor::register_internal_descriptor(
> int op_type, socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
>{
> descriptor_data = allocate_descriptor_state();
>
> (void)0
>
> ;
>
> {
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> descriptor_data->reactor_ = this;
> descriptor_data->descriptor_ = descriptor;
> descriptor_data->shutdown_ = false;
> descriptor_data->op_queue_[op_type].push(op);
> for (int i = 0; i < max_ops; ++i)
> descriptor_data->try_speculative_[i] = true;
> }
>
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
> descriptor_data->registered_events_ = ev.events;
> ev.data.ptr = descriptor_data;
> int result = epoll_ctl(epoll_fd_, 1, descriptor, &ev);
> if (result != 0)
> return (*__errno_location ());
>
> return 0;
>}
>
>void epoll_reactor::move_descriptor(socket_type,
> epoll_reactor::per_descriptor_data& target_descriptor_data,
> epoll_reactor::per_descriptor_data& source_descriptor_data)
>{
> target_descriptor_data = source_descriptor_data;
> source_descriptor_data = 0;
>}
>
>void epoll_reactor::start_op(int op_type, socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
> bool is_continuation, bool allow_speculative)
>{
> if (!descriptor_data)
> {
> op->ec_ = boost::asio::error::bad_descriptor;
> post_immediate_completion(op, is_continuation);
> return;
> }
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> if (descriptor_data->shutdown_)
> {
> post_immediate_completion(op, is_continuation);
> return;
> }
>
> if (descriptor_data->op_queue_[op_type].empty())
> {
> if (allow_speculative
> && (op_type != read_op
> || descriptor_data->op_queue_[except_op].empty()))
> {
> if (descriptor_data->try_speculative_[op_type])
> {
> if (reactor_op::status status = op->perform())
> {
> if (status == reactor_op::done_and_exhausted)
> if (descriptor_data->registered_events_ != 0)
> descriptor_data->try_speculative_[op_type] = false;
> descriptor_lock.unlock();
> scheduler_.post_immediate_completion(op, is_continuation);
> return;
> }
> }
>
> if (descriptor_data->registered_events_ == 0)
> {
> op->ec_ = boost::asio::error::operation_not_supported;
> scheduler_.post_immediate_completion(op, is_continuation);
> return;
> }
>
> if (op_type == write_op)
> {
> if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
> {
> epoll_event ev = { 0, { 0 } };
> ev.events = descriptor_data->registered_events_ | EPOLLOUT;
> ev.data.ptr = descriptor_data;
> if (epoll_ctl(epoll_fd_, 3, descriptor, &ev) == 0)
> {
> descriptor_data->registered_events_ |= ev.events;
> }
> else
> {
> op->ec_ = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
> scheduler_.post_immediate_completion(op, is_continuation);
> return;
> }
> }
> }
> }
> else if (descriptor_data->registered_events_ == 0)
> {
> op->ec_ = boost::asio::error::operation_not_supported;
> scheduler_.post_immediate_completion(op, is_continuation);
> return;
> }
> else
> {
> if (op_type == write_op)
> {
> descriptor_data->registered_events_ |= EPOLLOUT;
> }
>
> epoll_event ev = { 0, { 0 } };
> ev.events = descriptor_data->registered_events_;
> ev.data.ptr = descriptor_data;
> epoll_ctl(epoll_fd_, 3, descriptor, &ev);
> }
> }
>
> descriptor_data->op_queue_[op_type].push(op);
> scheduler_.work_started();
>}
>
>void epoll_reactor::cancel_ops(socket_type,
> epoll_reactor::per_descriptor_data& descriptor_data)
>{
> if (!descriptor_data)
> return;
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> op_queue<operation> ops;
> for (int i = 0; i < max_ops; ++i)
> {
> while (reactor_op* op = descriptor_data->op_queue_[i].front())
> {
> op->ec_ = boost::asio::error::operation_aborted;
> descriptor_data->op_queue_[i].pop();
> ops.push(op);
> }
> }
>
> descriptor_lock.unlock();
>
> scheduler_.post_deferred_completions(ops);
>}
>
>void epoll_reactor::deregister_descriptor(socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
>{
> if (!descriptor_data)
> return;
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> if (!descriptor_data->shutdown_)
> {
> if (closing)
> {
>
>
> }
> else if (descriptor_data->registered_events_ != 0)
> {
> epoll_event ev = { 0, { 0 } };
> epoll_ctl(epoll_fd_, 2, descriptor, &ev);
> }
>
> op_queue<operation> ops;
> for (int i = 0; i < max_ops; ++i)
> {
> while (reactor_op* op = descriptor_data->op_queue_[i].front())
> {
> op->ec_ = boost::asio::error::operation_aborted;
> descriptor_data->op_queue_[i].pop();
> ops.push(op);
> }
> }
>
> descriptor_data->descriptor_ = -1;
> descriptor_data->shutdown_ = true;
>
> descriptor_lock.unlock();
>
> (void)0
>
> ;
>
> scheduler_.post_deferred_completions(ops);
>
>
>
> }
> else
> {
>
>
> descriptor_data = 0;
> }
>}
>
>void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
> epoll_reactor::per_descriptor_data& descriptor_data)
>{
> if (!descriptor_data)
> return;
>
> mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
>
> if (!descriptor_data->shutdown_)
> {
> epoll_event ev = { 0, { 0 } };
> epoll_ctl(epoll_fd_, 2, descriptor, &ev);
>
> op_queue<operation> ops;
> for (int i = 0; i < max_ops; ++i)
> ops.push(descriptor_data->op_queue_[i]);
>
> descriptor_data->descriptor_ = -1;
> descriptor_data->shutdown_ = true;
>
> descriptor_lock.unlock();
>
> (void)0
>
> ;
>
>
>
> }
> else
> {
>
>
> descriptor_data = 0;
> }
>}
>
>void epoll_reactor::cleanup_descriptor_data(
> per_descriptor_data& descriptor_data)
>{
> if (descriptor_data)
> {
> free_descriptor_state(descriptor_data);
> descriptor_data = 0;
> }
>}
>
>void epoll_reactor::run(long usec, op_queue<operation>& ops)
>{
>
>
>
>
>
>
>
> int timeout;
> if (usec == 0)
> timeout = 0;
> else
> {
> timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
> if (timer_fd_ == -1)
> {
> mutex::scoped_lock lock(mutex_);
> timeout = get_timeout(timeout);
> }
> }
>
>
> epoll_event events[128];
> int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
># 504 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 3 4
> bool check_timers = (timer_fd_ == -1);
>
>
>
>
>
> for (int i = 0; i < num_events; ++i)
> {
> void* ptr = events[i].data.ptr;
> if (ptr == &interrupter_)
> {
>
>
>
>
>
>
> if (timer_fd_ == -1)
> check_timers = true;
>
>
>
> }
>
> else if (ptr == &timer_fd_)
> {
> check_timers = true;
> }
>
> else
> {
>
>
>
> descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
> if (!ops.is_enqueued(descriptor_data))
> {
> descriptor_data->set_ready_events(events[i].events);
> ops.push(descriptor_data);
> }
> else
> {
> descriptor_data->add_ready_events(events[i].events);
> }
> }
> }
>
> if (check_timers)
> {
> mutex::scoped_lock common_lock(mutex_);
> timer_queues_.get_ready_timers(ops);
>
>
> if (timer_fd_ != -1)
> {
> itimerspec new_timeout;
> itimerspec old_timeout;
> int flags = get_timeout(new_timeout);
> timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
> }
>
> }
>}
>
>void epoll_reactor::interrupt()
>{
> epoll_event ev = { 0, { 0 } };
> ev.events = EPOLLIN | EPOLLERR | EPOLLET;
> ev.data.ptr = &interrupter_;
> epoll_ctl(epoll_fd_, 3, interrupter_.read_descriptor(), &ev);
>}
>
>int epoll_reactor::do_epoll_create()
>{
>
> int fd = epoll_create1(EPOLL_CLOEXEC);
>
>
>
>
>
> if (fd == -1 && ((*__errno_location ()) == 22 || (*__errno_location ()) == 38))
> {
> fd = epoll_create(epoll_size);
> if (fd != -1)
> ::fcntl(fd, 2, 1);
> }
>
> if (fd == -1)
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "epoll");
> }
>
> return fd;
>}
>
>int epoll_reactor::do_timerfd_create()
>{
>
>
> int fd = timerfd_create(1, TFD_CLOEXEC);
>
>
>
>
>
> if (fd == -1 && (*__errno_location ()) == 22)
> {
> fd = timerfd_create(1, 0);
> if (fd != -1)
> ::fcntl(fd, 2, 1);
> }
>
> return fd;
>
>
>
>}
>
>epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
>{
> mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
> return registered_descriptors_.alloc((((static_cast<unsigned>(scheduler_.concurrency_hint()) & (0xFFFF0000u | 0x4u)) ^ 0xA5100000u) != 0)
> );
>}
>
>void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
>{
> mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
> registered_descriptors_.free(s);
>}
>
>void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
>{
> mutex::scoped_lock lock(mutex_);
> timer_queues_.insert(&queue);
>}
>
>void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
>{
> mutex::scoped_lock lock(mutex_);
> timer_queues_.erase(&queue);
>}
>
>void epoll_reactor::update_timeout()
>{
>
> if (timer_fd_ != -1)
> {
> itimerspec new_timeout;
> itimerspec old_timeout;
> int flags = get_timeout(new_timeout);
> timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
> return;
> }
>
> interrupt();
>}
>
>int epoll_reactor::get_timeout(int msec)
>{
>
>
> const int max_msec = 5 * 60 * 1000;
> return timer_queues_.wait_duration_msec(
> (msec < 0 || max_msec < msec) ? max_msec : msec);
>}
>
>
>int epoll_reactor::get_timeout(itimerspec& ts)
>{
> ts.it_interval.tv_sec = 0;
> ts.it_interval.tv_nsec = 0;
>
> long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
> ts.it_value.tv_sec = usec / 1000000;
> ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
>
> return usec ? 0 : TFD_TIMER_ABSTIME;
>}
>
>
>struct epoll_reactor::perform_io_cleanup_on_block_exit
>{
> explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
> : reactor_(r), first_op_(0)
> {
> }
>
> ~perform_io_cleanup_on_block_exit()
> {
> if (first_op_)
> {
>
> if (!ops_.empty())
> reactor_->scheduler_.post_deferred_completions(ops_);
>
>
>
>
> }
> else
> {
>
>
>
> reactor_->scheduler_.compensating_work_started();
> }
> }
>
> epoll_reactor* reactor_;
> op_queue<operation> ops_;
> operation* first_op_;
>};
>
>epoll_reactor::descriptor_state::descriptor_state(bool locking)
> : operation(&epoll_reactor::descriptor_state::do_complete),
> mutex_(locking)
>{
>}
>
>operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
>{
> mutex_.lock();
> perform_io_cleanup_on_block_exit io_cleanup(reactor_);
> mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);
>
>
>
> static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
> for (int j = max_ops - 1; j >= 0; --j)
> {
> if (events & (flag[j] | EPOLLERR | EPOLLHUP))
> {
> try_speculative_[j] = true;
> while (reactor_op* op = op_queue_[j].front())
> {
> if (reactor_op::status status = op->perform())
> {
> op_queue_[j].pop();
> io_cleanup.ops_.push(op);
> if (status == reactor_op::done_and_exhausted)
> {
> try_speculative_[j] = false;
> break;
> }
> }
> else
> break;
> }
> }
> }
>
>
>
> io_cleanup.first_op_ = io_cleanup.ops_.front();
> io_cleanup.ops_.pop();
> return io_cleanup.first_op_;
>}
>
>void epoll_reactor::descriptor_state::do_complete(
> void* owner, operation* base,
> const boost::system::error_code& ec, std::size_t bytes_transferred)
>{
> if (owner)
> {
> descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
> uint32_t events = static_cast<uint32_t>(bytes_transferred);
> if (operation* op = descriptor_data->perform_io(events))
> {
> op->complete(owner, ec, 0);
> }
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 786 "/usr/include/boost/asio/detail/impl/epoll_reactor.ipp" 2 3 4
># 260 "/usr/include/boost/asio/detail/epoll_reactor.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/reactor.hpp" 2 3 4
># 24 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/scheduler.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/scheduler_thread_info.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/scheduler_thread_info.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/scheduler_thread_info.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class scheduler;
>class scheduler_operation;
>
>struct scheduler_thread_info : public thread_info_base
>{
> op_queue<scheduler_operation> private_op_queue;
> long private_outstanding_work;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 41 "/usr/include/boost/asio/detail/scheduler_thread_info.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct scheduler::task_cleanup
>{
> ~task_cleanup()
> {
> if (this_thread_->private_outstanding_work > 0)
> {
> boost::asio::detail::increment(
> scheduler_->outstanding_work_,
> this_thread_->private_outstanding_work);
> }
> this_thread_->private_outstanding_work = 0;
>
>
>
> lock_->lock();
> scheduler_->task_interrupted_ = true;
> scheduler_->op_queue_.push(this_thread_->private_op_queue);
> scheduler_->op_queue_.push(&scheduler_->task_operation_);
> }
>
> scheduler* scheduler_;
> mutex::scoped_lock* lock_;
> thread_info* this_thread_;
>};
>
>struct scheduler::work_cleanup
>{
> ~work_cleanup()
> {
> if (this_thread_->private_outstanding_work > 1)
> {
> boost::asio::detail::increment(
> scheduler_->outstanding_work_,
> this_thread_->private_outstanding_work - 1);
> }
> else if (this_thread_->private_outstanding_work < 1)
> {
> scheduler_->work_finished();
> }
> this_thread_->private_outstanding_work = 0;
>
>
> if (!this_thread_->private_op_queue.empty())
> {
> lock_->lock();
> scheduler_->op_queue_.push(this_thread_->private_op_queue);
> }
>
> }
>
> scheduler* scheduler_;
> mutex::scoped_lock* lock_;
> thread_info* this_thread_;
>};
>
>scheduler::scheduler(
> boost::asio::execution_context& ctx, int concurrency_hint)
> : boost::asio::detail::execution_context_service_base<scheduler>(ctx),
> one_thread_(concurrency_hint == 1
> || !(((static_cast<unsigned>(concurrency_hint) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
>
> || !(((static_cast<unsigned>(concurrency_hint) & (0xFFFF0000u | 0x4u)) ^ 0xA5100000u) != 0)
> ),
> mutex_((((static_cast<unsigned>(concurrency_hint) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
> ),
> task_(0),
> task_interrupted_(true),
> outstanding_work_(0),
> stopped_(false),
> shutdown_(false),
> concurrency_hint_(concurrency_hint)
>{
> (void)0;
>}
>
>void scheduler::shutdown()
>{
> mutex::scoped_lock lock(mutex_);
> shutdown_ = true;
> lock.unlock();
>
>
> while (!op_queue_.empty())
> {
> operation* o = op_queue_.front();
> op_queue_.pop();
> if (o != &task_operation_)
> o->destroy();
> }
>
>
> task_ = 0;
>}
>
>void scheduler::init_task()
>{
> mutex::scoped_lock lock(mutex_);
> if (!shutdown_ && !task_)
> {
> task_ = &use_service<reactor>(this->context());
> op_queue_.push(&task_operation_);
> wake_one_thread_and_unlock(lock);
> }
>}
>
>std::size_t scheduler::run(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.private_outstanding_work = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
> std::size_t n = 0;
> for (; do_run_one(lock, this_thread, ec); lock.lock())
> if (n != (std::numeric_limits<std::size_t>::max)())
> ++n;
> return n;
>}
>
>std::size_t scheduler::run_one(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.private_outstanding_work = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
> return do_run_one(lock, this_thread, ec);
>}
>
>std::size_t scheduler::wait_one(long usec, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.private_outstanding_work = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
> return do_wait_one(lock, this_thread, usec, ec);
>}
>
>std::size_t scheduler::poll(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.private_outstanding_work = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
>
>
>
>
> if (one_thread_)
> if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
> op_queue_.push(outer_info->private_op_queue);
>
>
> std::size_t n = 0;
> for (; do_poll_one(lock, this_thread, ec); lock.lock())
> if (n != (std::numeric_limits<std::size_t>::max)())
> ++n;
> return n;
>}
>
>std::size_t scheduler::poll_one(boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (outstanding_work_ == 0)
> {
> stop();
> return 0;
> }
>
> thread_info this_thread;
> this_thread.private_outstanding_work = 0;
> thread_call_stack::context ctx(this, this_thread);
>
> mutex::scoped_lock lock(mutex_);
>
>
>
>
>
> if (one_thread_)
> if (thread_info* outer_info = static_cast<thread_info*>(ctx.next_by_key()))
> op_queue_.push(outer_info->private_op_queue);
>
>
> return do_poll_one(lock, this_thread, ec);
>}
>
>void scheduler::stop()
>{
> mutex::scoped_lock lock(mutex_);
> stop_all_threads(lock);
>}
>
>bool scheduler::stopped() const
>{
> mutex::scoped_lock lock(mutex_);
> return stopped_;
>}
>
>void scheduler::restart()
>{
> mutex::scoped_lock lock(mutex_);
> stopped_ = false;
>}
>
>void scheduler::compensating_work_started()
>{
> thread_info_base* this_thread = thread_call_stack::contains(this);
> ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
>}
>
>void scheduler::post_immediate_completion(
> scheduler::operation* op, bool is_continuation)
>{
>
> if (one_thread_ || is_continuation)
> {
> if (thread_info_base* this_thread = thread_call_stack::contains(this))
> {
> ++static_cast<thread_info*>(this_thread)->private_outstanding_work;
> static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
> return;
> }
> }
>
>
>
>
> work_started();
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(op);
> wake_one_thread_and_unlock(lock);
>}
>
>void scheduler::post_deferred_completion(scheduler::operation* op)
>{
>
> if (one_thread_)
> {
> if (thread_info_base* this_thread = thread_call_stack::contains(this))
> {
> static_cast<thread_info*>(this_thread)->private_op_queue.push(op);
> return;
> }
> }
>
>
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(op);
> wake_one_thread_and_unlock(lock);
>}
>
>void scheduler::post_deferred_completions(
> op_queue<scheduler::operation>& ops)
>{
> if (!ops.empty())
> {
>
> if (one_thread_)
> {
> if (thread_info_base* this_thread = thread_call_stack::contains(this))
> {
> static_cast<thread_info*>(this_thread)->private_op_queue.push(ops);
> return;
> }
> }
>
>
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(ops);
> wake_one_thread_and_unlock(lock);
> }
>}
>
>void scheduler::do_dispatch(
> scheduler::operation* op)
>{
> work_started();
> mutex::scoped_lock lock(mutex_);
> op_queue_.push(op);
> wake_one_thread_and_unlock(lock);
>}
>
>void scheduler::abandon_operations(
> op_queue<scheduler::operation>& ops)
>{
> op_queue<scheduler::operation> ops2;
> ops2.push(ops);
>}
>
>std::size_t scheduler::do_run_one(mutex::scoped_lock& lock,
> scheduler::thread_info& this_thread,
> const boost::system::error_code& ec)
>{
> while (!stopped_)
> {
> if (!op_queue_.empty())
> {
>
> operation* o = op_queue_.front();
> op_queue_.pop();
> bool more_handlers = (!op_queue_.empty());
>
> if (o == &task_operation_)
> {
> task_interrupted_ = more_handlers;
>
> if (more_handlers && !one_thread_)
> wakeup_event_.unlock_and_signal_one(lock);
> else
> lock.unlock();
>
> task_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
>
>
> task_->run(more_handlers ? 0 : -1, this_thread.private_op_queue);
> }
> else
> {
> std::size_t task_result = o->task_result_;
>
> if (more_handlers && !one_thread_)
> wake_one_thread_and_unlock(lock);
> else
> lock.unlock();
>
>
> work_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
> o->complete(this, ec, task_result);
>
> return 1;
> }
> }
> else
> {
> wakeup_event_.clear(lock);
> wakeup_event_.wait(lock);
> }
> }
>
> return 0;
>}
>
>std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock,
> scheduler::thread_info& this_thread, long usec,
> const boost::system::error_code& ec)
>{
> if (stopped_)
> return 0;
>
> operation* o = op_queue_.front();
> if (o == 0)
> {
> wakeup_event_.clear(lock);
> wakeup_event_.wait_for_usec(lock, usec);
> usec = 0;
> o = op_queue_.front();
> }
>
> if (o == &task_operation_)
> {
> op_queue_.pop();
> bool more_handlers = (!op_queue_.empty());
>
> task_interrupted_ = more_handlers;
>
> if (more_handlers && !one_thread_)
> wakeup_event_.unlock_and_signal_one(lock);
> else
> lock.unlock();
>
> {
> task_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
>
>
> task_->run(more_handlers ? 0 : usec, this_thread.private_op_queue);
> }
>
> o = op_queue_.front();
> if (o == &task_operation_)
> {
> if (!one_thread_)
> wakeup_event_.maybe_unlock_and_signal_one(lock);
> return 0;
> }
> }
>
> if (o == 0)
> return 0;
>
> op_queue_.pop();
> bool more_handlers = (!op_queue_.empty());
>
> std::size_t task_result = o->task_result_;
>
> if (more_handlers && !one_thread_)
> wake_one_thread_and_unlock(lock);
> else
> lock.unlock();
>
>
> work_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
> o->complete(this, ec, task_result);
>
> return 1;
>}
>
>std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock,
> scheduler::thread_info& this_thread,
> const boost::system::error_code& ec)
>{
> if (stopped_)
> return 0;
>
> operation* o = op_queue_.front();
> if (o == &task_operation_)
> {
> op_queue_.pop();
> lock.unlock();
>
> {
> task_cleanup c = { this, &lock, &this_thread };
> (void)c;
>
>
>
>
> task_->run(0, this_thread.private_op_queue);
> }
>
> o = op_queue_.front();
> if (o == &task_operation_)
> {
> wakeup_event_.maybe_unlock_and_signal_one(lock);
> return 0;
> }
> }
>
> if (o == 0)
> return 0;
>
> op_queue_.pop();
> bool more_handlers = (!op_queue_.empty());
>
> std::size_t task_result = o->task_result_;
>
> if (more_handlers && !one_thread_)
> wake_one_thread_and_unlock(lock);
> else
> lock.unlock();
>
>
> work_cleanup on_exit = { this, &lock, &this_thread };
> (void)on_exit;
>
>
> o->complete(this, ec, task_result);
>
> return 1;
>}
>
>void scheduler::stop_all_threads(
> mutex::scoped_lock& lock)
>{
> stopped_ = true;
> wakeup_event_.signal_all(lock);
>
> if (!task_interrupted_ && task_)
> {
> task_interrupted_ = true;
> task_->interrupt();
> }
>}
>
>void scheduler::wake_one_thread_and_unlock(
> mutex::scoped_lock& lock)
>{
> if (!wakeup_event_.maybe_unlock_and_signal_one(lock))
> {
> if (!task_interrupted_ && task_)
> {
> task_interrupted_ = true;
> task_->interrupt();
> }
> lock.unlock();
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 572 "/usr/include/boost/asio/detail/impl/scheduler.ipp" 2 3 4
># 213 "/usr/include/boost/asio/detail/scheduler.hpp" 2 3 4
># 20 "/usr/include/boost/asio/system_context.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/thread_group.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/thread_group.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/thread.hpp" 1 3 4
># 31 "/usr/include/boost/asio/detail/thread.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_thread.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/posix_thread.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/posix_thread.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>extern "C"
>{
> inline void* boost_asio_detail_posix_thread_function(void* arg);
>}
>
>class posix_thread
> : private noncopyable
>{
>public:
>
> template <typename Function>
> posix_thread(Function f, unsigned int = 0)
> : joined_(false)
> {
> start_thread(new func<Function>(f));
> }
>
>
> inline ~posix_thread();
>
>
> inline void join();
>
>
> inline static std::size_t hardware_concurrency();
>
>private:
> friend void* boost_asio_detail_posix_thread_function(void* arg);
>
> class func_base
> {
> public:
> virtual ~func_base() {}
> virtual void run() = 0;
> };
>
> struct auto_func_base_ptr
> {
> func_base* ptr;
> ~auto_func_base_ptr() { delete ptr; }
> };
>
> template <typename Function>
> class func
> : public func_base
> {
> public:
> func(Function f)
> : f_(f)
> {
> }
>
> virtual void run()
> {
> f_();
> }
>
> private:
> Function f_;
> };
>
> inline void start_thread(func_base* arg);
>
> ::pthread_t thread_;
> bool joined_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 104 "/usr/include/boost/asio/detail/posix_thread.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_thread.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>posix_thread::~posix_thread()
>{
> if (!joined_)
> ::pthread_detach(thread_);
>}
>
>void posix_thread::join()
>{
> if (!joined_)
> {
> ::pthread_join(thread_, 0);
> joined_ = true;
> }
>}
>
>std::size_t posix_thread::hardware_concurrency()
>{
>
> long result = sysconf(_SC_NPROCESSORS_ONLN);
> if (result > 0)
> return result;
>
> return 0;
>}
>
>void posix_thread::start_thread(func_base* arg)
>{
> int error = ::pthread_create(&thread_, 0,
> boost_asio_detail_posix_thread_function, arg);
> if (error != 0)
> {
> delete arg;
> boost::system::error_code ec(error,
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "thread");
> }
>}
>
>void* boost_asio_detail_posix_thread_function(void* arg)
>{
> posix_thread::auto_func_base_ptr func = {
> static_cast<posix_thread::func_base*>(arg) };
> func.ptr->run();
> return 0;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 83 "/usr/include/boost/asio/detail/impl/posix_thread.ipp" 2 3 4
># 107 "/usr/include/boost/asio/detail/posix_thread.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/thread.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
># 53 "/usr/include/boost/asio/detail/thread.hpp" 3 4
>typedef posix_thread thread;
>
>
>
>
>}
>}
>}
># 21 "/usr/include/boost/asio/detail/thread_group.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class thread_group
>{
>public:
>
> thread_group()
> : first_(0)
> {
> }
>
>
> ~thread_group()
> {
> join();
> }
>
>
> template <typename Function>
> void create_thread(Function f)
> {
> first_ = new item(f, first_);
> }
>
>
> template <typename Function>
> void create_threads(Function f, std::size_t num_threads)
> {
> for (std::size_t i = 0; i < num_threads; ++i)
> create_thread(f);
> }
>
>
> void join()
> {
> while (first_)
> {
> first_->thread_.join();
> item* tmp = first_;
> first_ = first_->next_;
> delete tmp;
> }
> }
>
>private:
>
> struct item
> {
> template <typename Function>
> explicit item(Function f, item* next)
> : thread_(f),
> next_(next)
> {
> }
>
> boost::asio::detail::thread thread_;
> item* next_;
> };
>
>
> item* first_;
>};
>
>}
>}
>}
># 21 "/usr/include/boost/asio/system_context.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/system_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class system_executor;
>
>
>class system_context : public execution_context
>{
>public:
>
> typedef system_executor executor_type;
>
>
> inline ~system_context();
>
>
> executor_type get_executor() noexcept;
>
>
> inline void stop();
>
>
> inline bool stopped() const noexcept;
>
>
> inline void join();
>
>
>
>
>
> inline system_context();
>
>private:
> friend class system_executor;
>
> struct thread_function;
>
>
> detail::scheduler& scheduler_;
>
>
> detail::thread_group threads_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 74 "/usr/include/boost/asio/system_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/system_context.hpp" 1 3 4
># 18 "/usr/include/boost/asio/impl/system_context.hpp" 3 4
># 1 "/usr/include/boost/asio/system_executor.hpp" 1 3 4
># 19 "/usr/include/boost/asio/impl/system_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/impl/system_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>inline system_context::executor_type
>system_context::get_executor() noexcept
>{
> return system_executor();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 35 "/usr/include/boost/asio/impl/system_context.hpp" 2 3 4
># 76 "/usr/include/boost/asio/system_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/system_context.ipp" 1 3 4
># 19 "/usr/include/boost/asio/impl/system_context.ipp" 3 4
># 1 "/usr/include/boost/asio/system_context.hpp" 1 3 4
># 20 "/usr/include/boost/asio/impl/system_context.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/impl/system_context.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>struct system_context::thread_function
>{
> detail::scheduler* scheduler_;
>
> void operator()()
> {
> boost::system::error_code ec;
> scheduler_->run(ec);
> }
>};
>
>system_context::system_context()
> : scheduler_(use_service<detail::scheduler>(*this))
>{
> scheduler_.work_started();
>
> thread_function f = { &scheduler_ };
> std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
> threads_.create_threads(f, num_threads ? num_threads : 2);
>}
>
>system_context::~system_context()
>{
> scheduler_.work_finished();
> scheduler_.stop();
> threads_.join();
>}
>
>void system_context::stop()
>{
> scheduler_.stop();
>}
>
>bool system_context::stopped() const noexcept
>{
> return scheduler_.stopped();
>}
>
>void system_context::join()
>{
> scheduler_.work_finished();
> threads_.join();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 74 "/usr/include/boost/asio/impl/system_context.ipp" 2 3 4
># 78 "/usr/include/boost/asio/system_context.hpp" 2 3 4
># 23 "/usr/include/boost/asio/impl/system_executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/impl/system_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>inline system_context& system_executor::context() const noexcept
>{
> return detail::global<system_context>();
>}
>
>template <typename Function, typename Allocator>
>void system_executor::dispatch(
> Function&& f, const Allocator&) const
>{
> typename decay<Function>::type tmp(static_cast<Function&&>(f));
> boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
>}
>
>template <typename Function, typename Allocator>
>void system_executor::post(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
> system_context& ctx = detail::global<system_context>();
>
>
> typedef detail::executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> ctx.scheduler_.post_immediate_completion(p.p, false);
> p.v = p.p = 0;
>}
>
>template <typename Function, typename Allocator>
>void system_executor::defer(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
> system_context& ctx = detail::global<system_context>();
>
>
> typedef detail::executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> ctx.scheduler_.post_immediate_completion(p.p, true);
> p.v = p.p = 0;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 86 "/usr/include/boost/asio/impl/system_executor.hpp" 2 3 4
># 130 "/usr/include/boost/asio/system_executor.hpp" 2 3 4
># 22 "/usr/include/boost/asio/associated_executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/associated_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename>
>struct associated_executor_check
>{
> typedef void type;
>};
>
>template <typename T, typename E, typename = void>
>struct associated_executor_impl
>{
> typedef E type;
>
> static type get(const T&, const E& e) noexcept
> {
> return e;
> }
>};
>
>template <typename T, typename E>
>struct associated_executor_impl<T, E,
> typename associated_executor_check<typename T::executor_type>::type>
>{
> typedef typename T::executor_type type;
>
> static type get(const T& t, const E&) noexcept
> {
> return t.get_executor();
> }
>};
>
>}
># 79 "/usr/include/boost/asio/associated_executor.hpp" 3 4
>template <typename T, typename Executor = system_executor>
>struct associated_executor
>{
>
>
>
>
>
> typedef typename detail::associated_executor_impl<T, Executor>::type type;
>
>
>
>
> static type get(const T& t,
> const Executor& ex = Executor()) noexcept
> {
> return detail::associated_executor_impl<T, Executor>::get(t, ex);
> }
>};
>
>
>
>
>
>template <typename T>
>inline typename associated_executor<T>::type
>get_associated_executor(const T& t) noexcept
>{
> return associated_executor<T>::get(t);
>}
>
>
>
>
>
>template <typename T, typename Executor>
>inline typename associated_executor<T, Executor>::type
>get_associated_executor(const T& t, const Executor& ex,
> typename enable_if<is_executor<
> Executor>::value>::type* = 0) noexcept
>{
> return associated_executor<T, Executor>::get(t, ex);
>}
>
>
>
>
>
>
>template <typename T, typename ExecutionContext>
>inline typename associated_executor<T,
> typename ExecutionContext::executor_type>::type
>get_associated_executor(const T& t, ExecutionContext& ctx,
> typename enable_if<is_convertible<ExecutionContext&,
> execution_context&>::value>::type* = 0) noexcept
>{
> return associated_executor<T,
> typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
>}
>
>
>
>template <typename T, typename Executor = system_executor>
>using associated_executor_t = typename associated_executor<T, Executor>::type;
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 150 "/usr/include/boost/asio/associated_executor.hpp" 2 3 4
># 22 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/basic_datagram_socket.hpp" 1 3 4
># 20 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/basic_socket.hpp" 1 3 4
># 20 "/usr/include/boost/asio/basic_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/basic_io_object.hpp" 1 3 4
># 19 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
># 1 "/usr/include/boost/asio/io_context.hpp" 1 3 4
># 24 "/usr/include/boost/asio/io_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 1 3 4
># 18 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/bind_handler.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/bind_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 3 4
># 1 "/usr/include/boost/asio/handler_continuation_hook.hpp" 1 3 4
># 20 "/usr/include/boost/asio/handler_continuation_hook.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/handler_continuation_hook.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 46 "/usr/include/boost/asio/handler_continuation_hook.hpp" 3 4
>inline bool asio_handler_is_continuation(...)
>{
> return false;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 55 "/usr/include/boost/asio/handler_continuation_hook.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
>
>
>
>
>namespace boost_asio_handler_cont_helpers {
>
>template <typename Context>
>inline bool is_continuation(Context& context)
>{
>
>
>
> using boost::asio::asio_handler_is_continuation;
> return asio_handler_is_continuation(
> boost::asio::detail::addressof(context));
>
>}
>
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 44 "/usr/include/boost/asio/detail/handler_cont_helpers.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler, typename Arg1>
>class binder1
>{
>public:
> template <typename T>
> binder1(int, T&& handler, const Arg1& arg1)
> : handler_(static_cast<T&&>(handler)),
> arg1_(arg1)
> {
> }
>
> binder1(Handler& handler, const Arg1& arg1)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1)
> {
> }
>
>
> binder1(const binder1& other)
> : handler_(other.handler_),
> arg1_(other.arg1_)
> {
> }
>
> binder1(binder1&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_))
> {
> }
>
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_));
> }
>
> void operator()() const
> {
> handler_(arg1_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
>};
>
>template <typename Handler, typename Arg1>
>inline void* asio_handler_allocate(std::size_t size,
> binder1<Handler, Arg1>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline bool asio_handler_is_continuation(
> binder1<Handler, Arg1>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1>
>inline void asio_handler_invoke(Function& function,
> binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1>
>inline void asio_handler_invoke(const Function& function,
> binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline binder1<typename decay<Handler>::type, Arg1> bind_handler(
> Handler&& handler, const Arg1& arg1)
>{
> return binder1<typename decay<Handler>::type, Arg1>(0,
> static_cast<Handler&&>(handler), arg1);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>class binder2
>{
>public:
> template <typename T>
> binder2(int, T&& handler,
> const Arg1& arg1, const Arg2& arg2)
> : handler_(static_cast<T&&>(handler)),
> arg1_(arg1),
> arg2_(arg2)
> {
> }
>
> binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2)
> {
> }
>
>
> binder2(const binder2& other)
> : handler_(other.handler_),
> arg1_(other.arg1_),
> arg2_(other.arg2_)
> {
> }
>
> binder2(binder2&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_)),
> arg2_(static_cast<Arg2&&>(other.arg2_))
> {
> }
>
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline void* asio_handler_allocate(std::size_t size,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline bool asio_handler_is_continuation(
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_invoke(Function& function,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_invoke(const Function& function,
> binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline binder2<typename decay<Handler>::type, Arg1, Arg2> bind_handler(
> Handler&& handler, const Arg1& arg1, const Arg2& arg2)
>{
> return binder2<typename decay<Handler>::type, Arg1, Arg2>(0,
> static_cast<Handler&&>(handler), arg1, arg2);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>class binder3
>{
>public:
> template <typename T>
> binder3(int, T&& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3)
> : handler_(static_cast<T&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3)
> {
> }
>
> binder3(Handler& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3)
> {
> }
>
>
> binder3(const binder3& other)
> : handler_(other.handler_),
> arg1_(other.arg1_),
> arg2_(other.arg2_),
> arg3_(other.arg3_)
> {
> }
>
> binder3(binder3&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_)),
> arg2_(static_cast<Arg2&&>(other.arg2_)),
> arg3_(static_cast<Arg3&&>(other.arg3_))
> {
> }
>
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_, arg3_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
> Arg3 arg3_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline void* asio_handler_allocate(std::size_t size,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline bool asio_handler_is_continuation(
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler,
> typename Arg1, typename Arg2, typename Arg3>
>inline void asio_handler_invoke(Function& function,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler,
> typename Arg1, typename Arg2, typename Arg3>
>inline void asio_handler_invoke(const Function& function,
> binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
>inline binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3> bind_handler(
> Handler&& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3)
>{
> return binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3>(0,
> static_cast<Handler&&>(handler), arg1, arg2, arg3);
>}
>
>template <typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>class binder4
>{
>public:
> template <typename T>
> binder4(int, T&& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
> : handler_(static_cast<T&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4)
> {
> }
>
> binder4(Handler& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4)
> {
> }
>
>
> binder4(const binder4& other)
> : handler_(other.handler_),
> arg1_(other.arg1_),
> arg2_(other.arg2_),
> arg3_(other.arg3_),
> arg4_(other.arg4_)
> {
> }
>
> binder4(binder4&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_)),
> arg2_(static_cast<Arg2&&>(other.arg2_)),
> arg3_(static_cast<Arg3&&>(other.arg3_)),
> arg4_(static_cast<Arg4&&>(other.arg4_))
> {
> }
>
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
> static_cast<const Arg4&>(arg4_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_, arg3_, arg4_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
> Arg3 arg3_;
> Arg4 arg4_;
>};
>
>template <typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>inline void* asio_handler_allocate(std::size_t size,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>inline bool asio_handler_is_continuation(
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>inline void asio_handler_invoke(Function& function,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>inline void asio_handler_invoke(const Function& function,
> binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4>
>inline binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>
>bind_handler(Handler&& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
>{
> return binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>(0,
> static_cast<Handler&&>(handler), arg1, arg2, arg3, arg4);
>}
>
>template <typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>class binder5
>{
>public:
> template <typename T>
> binder5(int, T&& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
> : handler_(static_cast<T&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4),
> arg5_(arg5)
> {
> }
>
> binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
> const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(arg2),
> arg3_(arg3),
> arg4_(arg4),
> arg5_(arg5)
> {
> }
>
>
> binder5(const binder5& other)
> : handler_(other.handler_),
> arg1_(other.arg1_),
> arg2_(other.arg2_),
> arg3_(other.arg3_),
> arg4_(other.arg4_),
> arg5_(other.arg5_)
> {
> }
>
> binder5(binder5&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_)),
> arg2_(static_cast<Arg2&&>(other.arg2_)),
> arg3_(static_cast<Arg3&&>(other.arg3_)),
> arg4_(static_cast<Arg4&&>(other.arg4_)),
> arg5_(static_cast<Arg5&&>(other.arg5_))
> {
> }
>
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_),
> static_cast<const Arg4&>(arg4_), static_cast<const Arg5&>(arg5_));
> }
>
> void operator()() const
> {
> handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
> Arg3 arg3_;
> Arg4 arg4_;
> Arg5 arg5_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>inline void* asio_handler_allocate(std::size_t size,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>inline bool asio_handler_is_continuation(
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4, typename Arg5>
>inline void asio_handler_invoke(Function& function,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1,
> typename Arg2, typename Arg3, typename Arg4, typename Arg5>
>inline void asio_handler_invoke(const Function& function,
> binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2,
> typename Arg3, typename Arg4, typename Arg5>
>inline binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>
>bind_handler(Handler&& handler, const Arg1& arg1,
> const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
>{
> return binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>(0,
> static_cast<Handler&&>(handler), arg1, arg2, arg3, arg4, arg5);
>}
>
>
>
>template <typename Handler, typename Arg1>
>class move_binder1
>{
>public:
> move_binder1(int, Handler&& handler,
> Arg1&& arg1)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(static_cast<Arg1&&>(arg1))
> {
> }
>
> move_binder1(move_binder1&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_))
> {
> }
>
> void operator()()
> {
> handler_(static_cast<Arg1&&>(arg1_));
> }
>
>
> Handler handler_;
> Arg1 arg1_;
>};
>
>template <typename Handler, typename Arg1>
>inline void* asio_handler_allocate(std::size_t size,
> move_binder1<Handler, Arg1>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> move_binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1>
>inline bool asio_handler_is_continuation(
> move_binder1<Handler, Arg1>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1>
>inline void asio_handler_invoke(Function&& function,
> move_binder1<Handler, Arg1>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> static_cast<Function&&>(function), this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>class move_binder2
>{
>public:
> move_binder2(int, Handler&& handler,
> const Arg1& arg1, Arg2&& arg2)
> : handler_(static_cast<Handler&&>(handler)),
> arg1_(arg1),
> arg2_(static_cast<Arg2&&>(arg2))
> {
> }
>
> move_binder2(move_binder2&& other)
> : handler_(static_cast<Handler&&>(other.handler_)),
> arg1_(static_cast<Arg1&&>(other.arg1_)),
> arg2_(static_cast<Arg2&&>(other.arg2_))
> {
> }
>
> void operator()()
> {
> handler_(static_cast<const Arg1&>(arg1_),
> static_cast<Arg2&&>(arg2_));
> }
>
>
> Handler handler_;
> Arg1 arg1_;
> Arg2 arg2_;
>};
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline void* asio_handler_allocate(std::size_t size,
> move_binder2<Handler, Arg1, Arg2>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> move_binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Handler, typename Arg1, typename Arg2>
>inline bool asio_handler_is_continuation(
> move_binder2<Handler, Arg1, Arg2>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
>}
>
>template <typename Function, typename Handler, typename Arg1, typename Arg2>
>inline void asio_handler_invoke(Function&& function,
> move_binder2<Handler, Arg1, Arg2>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> static_cast<Function&&>(function), this_handler->handler_);
>}
>
>
>
>}
>
>template <typename Handler, typename Arg1, typename Allocator>
>struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator>
>{
> typedef typename associated_allocator<Handler, Allocator>::type type;
>
> static type get(const detail::binder1<Handler, Arg1>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<Handler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
>struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator>
>{
> typedef typename associated_allocator<Handler, Allocator>::type type;
>
> static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<Handler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Handler, typename Arg1, typename Executor>
>struct associated_executor<detail::binder1<Handler, Arg1>, Executor>
>{
> typedef typename associated_executor<Handler, Executor>::type type;
>
> static type get(const detail::binder1<Handler, Arg1>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<Handler, Executor>::get(h.handler_, ex);
> }
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Executor>
>struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor>
>{
> typedef typename associated_executor<Handler, Executor>::type type;
>
> static type get(const detail::binder2<Handler, Arg1, Arg2>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<Handler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename Handler, typename Arg1, typename Allocator>
>struct associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator>
>{
> typedef typename associated_allocator<Handler, Allocator>::type type;
>
> static type get(const detail::move_binder1<Handler, Arg1>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<Handler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Allocator>
>struct associated_allocator<
> detail::move_binder2<Handler, Arg1, Arg2>, Allocator>
>{
> typedef typename associated_allocator<Handler, Allocator>::type type;
>
> static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<Handler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Handler, typename Arg1, typename Executor>
>struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor>
>{
> typedef typename associated_executor<Handler, Executor>::type type;
>
> static type get(const detail::move_binder1<Handler, Arg1>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<Handler, Executor>::get(h.handler_, ex);
> }
>};
>
>template <typename Handler, typename Arg1, typename Arg2, typename Executor>
>struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor>
>{
> typedef typename associated_executor<Handler, Executor>::type type;
>
> static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<Handler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 817 "/usr/include/boost/asio/detail/bind_handler.hpp" 2 3 4
># 19 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct is_continuation_delegated
>{
> template <typename Dispatcher, typename Handler>
> bool operator()(Dispatcher&, Handler& handler) const
> {
> return boost_asio_handler_cont_helpers::is_continuation(handler);
> }
>};
>
>struct is_continuation_if_running
>{
> template <typename Dispatcher, typename Handler>
> bool operator()(Dispatcher& dispatcher, Handler&) const
> {
> return dispatcher.running_in_this_thread();
> }
>};
>
>template <typename Dispatcher, typename Handler,
> typename IsContinuation = is_continuation_delegated>
>class wrapped_handler
>{
>public:
> typedef void result_type;
>
> wrapped_handler(Dispatcher dispatcher, Handler& handler)
> : dispatcher_(dispatcher),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
>
> wrapped_handler(const wrapped_handler& other)
> : dispatcher_(other.dispatcher_),
> handler_(other.handler_)
> {
> }
>
> wrapped_handler(wrapped_handler&& other)
> : dispatcher_(other.dispatcher_),
> handler_(static_cast<Handler&&>(other.handler_))
> {
> }
>
>
> void operator()()
> {
> dispatcher_.dispatch(static_cast<Handler&&>(handler_));
> }
>
> void operator()() const
> {
> dispatcher_.dispatch(handler_);
> }
>
> template <typename Arg1>
> void operator()(const Arg1& arg1)
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
> }
>
> template <typename Arg1>
> void operator()(const Arg1& arg1) const
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
> }
>
> template <typename Arg1, typename Arg2>
> void operator()(const Arg1& arg1, const Arg2& arg2)
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
> }
>
> template <typename Arg1, typename Arg2>
> void operator()(const Arg1& arg1, const Arg2& arg2) const
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const
> {
> dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4)
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4) const
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
> typename Arg5>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4, const Arg5& arg5)
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
> }
>
> template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
> typename Arg5>
> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
> const Arg4& arg4, const Arg5& arg5) const
> {
> dispatcher_.dispatch(
> detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
> }
>
>
> Dispatcher dispatcher_;
> Handler handler_;
>};
>
>template <typename Handler, typename Context>
>class rewrapped_handler
>{
>public:
> explicit rewrapped_handler(Handler& handler, const Context& context)
> : context_(context),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
> explicit rewrapped_handler(const Handler& handler, const Context& context)
> : context_(context),
> handler_(handler)
> {
> }
>
>
> rewrapped_handler(const rewrapped_handler& other)
> : context_(other.context_),
> handler_(other.handler_)
> {
> }
>
> rewrapped_handler(rewrapped_handler&& other)
> : context_(static_cast<Context&&>(other.context_)),
> handler_(static_cast<Handler&&>(other.handler_))
> {
> }
>
>
> void operator()()
> {
> handler_();
> }
>
> void operator()() const
> {
> handler_();
> }
>
>
> Context context_;
> Handler handler_;
>};
>
>template <typename Dispatcher, typename Handler, typename IsContinuation>
>inline void* asio_handler_allocate(std::size_t size,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Dispatcher, typename Handler, typename IsContinuation>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Dispatcher, typename Handler, typename IsContinuation>
>inline bool asio_handler_is_continuation(
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
>}
>
>template <typename Function, typename Dispatcher,
> typename Handler, typename IsContinuation>
>inline void asio_handler_invoke(Function& function,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> this_handler->dispatcher_.dispatch(
> rewrapped_handler<Function, Handler>(
> function, this_handler->handler_));
>}
>
>template <typename Function, typename Dispatcher,
> typename Handler, typename IsContinuation>
>inline void asio_handler_invoke(const Function& function,
> wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
>{
> this_handler->dispatcher_.dispatch(
> rewrapped_handler<Function, Handler>(
> function, this_handler->handler_));
>}
>
>template <typename Handler, typename Context>
>inline void* asio_handler_allocate(std::size_t size,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->context_);
>}
>
>template <typename Handler, typename Context>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->context_);
>}
>
>template <typename Dispatcher, typename Context>
>inline bool asio_handler_is_continuation(
> rewrapped_handler<Dispatcher, Context>* this_handler)
>{
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->context_);
>}
>
>template <typename Function, typename Handler, typename Context>
>inline void asio_handler_invoke(Function& function,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->context_);
>}
>
>template <typename Function, typename Handler, typename Context>
>inline void asio_handler_invoke(const Function& function,
> rewrapped_handler<Handler, Context>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->context_);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 292 "/usr/include/boost/asio/detail/wrapped_handler.hpp" 2 3 4
># 25 "/usr/include/boost/asio/io_context.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/chrono.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/chrono.hpp" 3 4
># 1 "/usr/include/c++/8/chrono" 1 3 4
># 32 "/usr/include/c++/8/chrono" 3 4
> 
># 33 "/usr/include/c++/8/chrono" 3
>
>
>
>
>
># 1 "/usr/include/c++/8/ratio" 1 3
># 32 "/usr/include/c++/8/ratio" 3
> 
># 33 "/usr/include/c++/8/ratio" 3
># 43 "/usr/include/c++/8/ratio" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/include/c++/8/ratio" 3
> template<intmax_t _Pn>
> struct __static_sign
> : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1>
> { };
>
> template<intmax_t _Pn>
> struct __static_abs
> : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value>
> { };
>
> template<intmax_t _Pn, intmax_t _Qn>
> struct __static_gcd
> : __static_gcd<_Qn, (_Pn % _Qn)>
> { };
>
> template<intmax_t _Pn>
> struct __static_gcd<_Pn, 0>
> : integral_constant<intmax_t, __static_abs<_Pn>::value>
> { };
>
> template<intmax_t _Qn>
> struct __static_gcd<0, _Qn>
> : integral_constant<intmax_t, __static_abs<_Qn>::value>
> { };
>
>
>
>
>
>
>
> template<intmax_t _Pn, intmax_t _Qn>
> struct __safe_multiply
> {
> private:
> static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
>
> static const uintmax_t __a0 = __static_abs<_Pn>::value % __c;
> static const uintmax_t __a1 = __static_abs<_Pn>::value / __c;
> static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;
> static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;
>
> static_assert(__a1 == 0 || __b1 == 0,
> "overflow in multiplication");
> static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
> "overflow in multiplication");
> static_assert(__b0 * __a0 <= 0x7fffffffffffffffL,
> "overflow in multiplication");
> static_assert((__a0 * __b1 + __b0 * __a1) * __c
> <= 0x7fffffffffffffffL - __b0 * __a0,
> "overflow in multiplication");
>
> public:
> static const intmax_t value = _Pn * _Qn;
> };
>
>
>
> template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
> struct __big_less
> : integral_constant<bool, (__hi1 < __hi2
> || (__hi1 == __hi2 && __lo1 < __lo2))>
> { };
>
> template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
> struct __big_add
> {
> static constexpr uintmax_t __lo = __lo1 + __lo2;
> static constexpr uintmax_t __hi = (__hi1 + __hi2 +
> (__lo1 + __lo2 < __lo1));
> };
>
>
> template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
> struct __big_sub
> {
> static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value,
> "Internal library error");
> static constexpr uintmax_t __lo = __lo1 - __lo2;
> static constexpr uintmax_t __hi = (__hi1 - __hi2 -
> (__lo1 < __lo2));
> };
>
>
> template<uintmax_t __x, uintmax_t __y>
> struct __big_mul
> {
> private:
> static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
> static constexpr uintmax_t __x0 = __x % __c;
> static constexpr uintmax_t __x1 = __x / __c;
> static constexpr uintmax_t __y0 = __y % __c;
> static constexpr uintmax_t __y1 = __y / __c;
> static constexpr uintmax_t __x0y0 = __x0 * __y0;
> static constexpr uintmax_t __x0y1 = __x0 * __y1;
> static constexpr uintmax_t __x1y0 = __x1 * __y0;
> static constexpr uintmax_t __x1y1 = __x1 * __y1;
> static constexpr uintmax_t __mix = __x0y1 + __x1y0;
> static constexpr uintmax_t __mix_lo = __mix * __c;
> static constexpr uintmax_t __mix_hi
> = __mix / __c + ((__mix < __x0y1) ? __c : 0);
> typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res;
> public:
> static constexpr uintmax_t __hi = _Res::__hi;
> static constexpr uintmax_t __lo = _Res::__lo;
> };
>
>
>
> template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
> struct __big_div_impl
> {
> private:
> static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)),
> "Internal library error");
> static_assert(__n1 < __d, "Internal library error");
> static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
> static constexpr uintmax_t __d1 = __d / __c;
> static constexpr uintmax_t __d0 = __d % __c;
>
> static constexpr uintmax_t __q1x = __n1 / __d1;
> static constexpr uintmax_t __r1x = __n1 % __d1;
> static constexpr uintmax_t __m = __q1x * __d0;
> static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;
> static constexpr uintmax_t __r1z = __r1y + __d;
> static constexpr uintmax_t __r1
> = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m))
> ? (__r1z + __d) : __r1z : __r1y) - __m;
> static constexpr uintmax_t __q1
> = __q1x - ((__r1y < __m)
> ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);
> static constexpr uintmax_t __q0x = __r1 / __d1;
> static constexpr uintmax_t __r0x = __r1 % __d1;
> static constexpr uintmax_t __n = __q0x * __d0;
> static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;
> static constexpr uintmax_t __r0z = __r0y + __d;
> static constexpr uintmax_t __r0
> = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n))
> ? (__r0z + __d) : __r0z : __r0y) - __n;
> static constexpr uintmax_t __q0
> = __q0x - ((__r0y < __n) ? ((__r0z >= __d)
> && (__r0z < __n)) ? 2 : 1 : 0);
>
> public:
> static constexpr uintmax_t __quot = __q1 * __c + __q0;
> static constexpr uintmax_t __rem = __r0;
>
> private:
> typedef __big_mul<__quot, __d> _Prod;
> typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum;
> static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
> "Internal library error");
> };
>
> template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
> struct __big_div
> {
> private:
> static_assert(__d != 0, "Internal library error");
> static_assert(sizeof (uintmax_t) == sizeof (unsigned long long),
> "This library calls __builtin_clzll on uintmax_t, which "
> "is unsafe on your platform. Please complain to "
> "http://gcc.gnu.org/bugzilla/");
> static constexpr int __shift = __builtin_clzll(__d);
> static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;
> static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;
> static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;
> static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;
> static constexpr uintmax_t __new_d = __d * __c1;
> static constexpr uintmax_t __new_n0 = __n0 * __c1;
> static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;
> static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;
> static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;
> typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;
>
> public:
> static constexpr uintmax_t __quot_hi = __n1 / __d;
> static constexpr uintmax_t __quot_lo = _Res::__quot;
> static constexpr uintmax_t __rem = _Res::__rem / __c1;
>
> private:
> typedef __big_mul<__quot_lo, __d> _P0;
> typedef __big_mul<__quot_hi, __d> _P1;
> typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum;
>
> static_assert(_P1::__hi == 0, "Internal library error");
> static_assert(_Sum::__hi >= _P0::__hi, "Internal library error");
>
> static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
> "Internal library error");
> static_assert(__rem < __d, "Internal library error");
> };
># 262 "/usr/include/c++/8/ratio" 3
> template<intmax_t _Num, intmax_t _Den = 1>
> struct ratio
> {
> static_assert(_Den != 0, "denominator cannot be zero");
> static_assert(_Num >= -0x7fffffffffffffffL && _Den >= -0x7fffffffffffffffL,
> "out of range");
>
>
> static constexpr intmax_t num =
> _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;
>
> static constexpr intmax_t den =
> __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;
>
> typedef ratio<num, den> type;
> };
>
> template<intmax_t _Num, intmax_t _Den>
> constexpr intmax_t ratio<_Num, _Den>::num;
>
> template<intmax_t _Num, intmax_t _Den>
> constexpr intmax_t ratio<_Num, _Den>::den;
>
> template<typename _R1, typename _R2>
> struct __ratio_multiply
> {
> private:
> static const intmax_t __gcd1 =
> __static_gcd<_R1::num, _R2::den>::value;
> static const intmax_t __gcd2 =
> __static_gcd<_R2::num, _R1::den>::value;
>
> public:
> typedef ratio<
> __safe_multiply<(_R1::num / __gcd1),
> (_R2::num / __gcd2)>::value,
> __safe_multiply<(_R1::den / __gcd2),
> (_R2::den / __gcd1)>::value> type;
>
> static constexpr intmax_t num = type::num;
> static constexpr intmax_t den = type::den;
> };
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_multiply<_R1, _R2>::num;
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_multiply<_R1, _R2>::den;
>
>
> template<typename _R1, typename _R2>
> using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;
>
> template<typename _R1, typename _R2>
> struct __ratio_divide
> {
> static_assert(_R2::num != 0, "division by 0");
>
> typedef typename __ratio_multiply<
> _R1,
> ratio<_R2::den, _R2::num>>::type type;
>
> static constexpr intmax_t num = type::num;
> static constexpr intmax_t den = type::den;
> };
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_divide<_R1, _R2>::num;
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_divide<_R1, _R2>::den;
>
>
> template<typename _R1, typename _R2>
> using ratio_divide = typename __ratio_divide<_R1, _R2>::type;
>
>
> template<typename _R1, typename _R2>
> struct ratio_equal
> : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
> { };
>
>
> template<typename _R1, typename _R2>
> struct ratio_not_equal
> : integral_constant<bool, !ratio_equal<_R1, _R2>::value>
> { };
>
>
> template<typename _R1, typename _R2,
> typename _Left = __big_mul<_R1::num,_R2::den>,
> typename _Right = __big_mul<_R2::num,_R1::den> >
> struct __ratio_less_impl_1
> : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
> _Right::__hi, _Right::__lo>::value>
> { };
>
> template<typename _R1, typename _R2,
> bool = (_R1::num == 0 || _R2::num == 0
> || (__static_sign<_R1::num>::value
> != __static_sign<_R2::num>::value)),
> bool = (__static_sign<_R1::num>::value == -1
> && __static_sign<_R2::num>::value == -1)>
> struct __ratio_less_impl
> : __ratio_less_impl_1<_R1, _R2>::type
> { };
>
> template<typename _R1, typename _R2>
> struct __ratio_less_impl<_R1, _R2, true, false>
> : integral_constant<bool, _R1::num < _R2::num>
> { };
>
> template<typename _R1, typename _R2>
> struct __ratio_less_impl<_R1, _R2, false, true>
> : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,
> ratio<-_R1::num, _R1::den> >::type
> { };
>
>
> template<typename _R1, typename _R2>
> struct ratio_less
> : __ratio_less_impl<_R1, _R2>::type
> { };
>
>
> template<typename _R1, typename _R2>
> struct ratio_less_equal
> : integral_constant<bool, !ratio_less<_R2, _R1>::value>
> { };
>
>
> template<typename _R1, typename _R2>
> struct ratio_greater
> : integral_constant<bool, ratio_less<_R2, _R1>::value>
> { };
>
>
> template<typename _R1, typename _R2>
> struct ratio_greater_equal
> : integral_constant<bool, !ratio_less<_R1, _R2>::value>
> { };
>
>
> template <typename _R1, typename _R2>
> inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
> template <typename _R1, typename _R2>
> inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value;
> template <typename _R1, typename _R2>
> inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value;
> template <typename _R1, typename _R2>
> inline constexpr bool ratio_less_equal_v =
> ratio_less_equal<_R1, _R2>::value;
> template <typename _R1, typename _R2>
> inline constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value;
> template <typename _R1, typename _R2>
> inline constexpr bool ratio_greater_equal_v
> = ratio_greater_equal<_R1, _R2>::value;
>
>
> template<typename _R1, typename _R2,
> bool = (_R1::num >= 0),
> bool = (_R2::num >= 0),
> bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>,
> ratio<__static_abs<_R2::num>::value, _R2::den> >::value>
> struct __ratio_add_impl
> {
> private:
> typedef typename __ratio_add_impl<
> ratio<-_R1::num, _R1::den>,
> ratio<-_R2::num, _R2::den> >::type __t;
> public:
> typedef ratio<-__t::num, __t::den> type;
> };
>
>
> template<typename _R1, typename _R2, bool __b>
> struct __ratio_add_impl<_R1, _R2, true, true, __b>
> {
> private:
> static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
> static constexpr uintmax_t __d2 = _R2::den / __g;
> typedef __big_mul<_R1::den, __d2> __d;
> typedef __big_mul<_R1::num, _R2::den / __g> __x;
> typedef __big_mul<_R2::num, _R1::den / __g> __y;
> typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
> static_assert(__n::__hi >= __x::__hi, "Internal library error");
> typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
> static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
> typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
> static_assert(__n_final::__rem == 0, "Internal library error");
> static_assert(__n_final::__quot_hi == 0 &&
> __n_final::__quot_lo <= 0x7fffffffffffffffL, "overflow in addition");
> typedef __big_mul<_R1::den / __g2, __d2> __d_final;
> static_assert(__d_final::__hi == 0 &&
> __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition");
> public:
> typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
> };
>
> template<typename _R1, typename _R2>
> struct __ratio_add_impl<_R1, _R2, false, true, true>
> : __ratio_add_impl<_R2, _R1>
> { };
>
>
> template<typename _R1, typename _R2>
> struct __ratio_add_impl<_R1, _R2, true, false, false>
> {
> private:
> static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
> static constexpr uintmax_t __d2 = _R2::den / __g;
> typedef __big_mul<_R1::den, __d2> __d;
> typedef __big_mul<_R1::num, _R2::den / __g> __x;
> typedef __big_mul<-_R2::num, _R1::den / __g> __y;
> typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
> typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
> static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
> typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
> static_assert(__n_final::__rem == 0, "Internal library error");
> static_assert(__n_final::__quot_hi == 0 &&
> __n_final::__quot_lo <= 0x7fffffffffffffffL, "overflow in addition");
> typedef __big_mul<_R1::den / __g2, __d2> __d_final;
> static_assert(__d_final::__hi == 0 &&
> __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition");
> public:
> typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
> };
>
> template<typename _R1, typename _R2>
> struct __ratio_add
> {
> typedef typename __ratio_add_impl<_R1, _R2>::type type;
> static constexpr intmax_t num = type::num;
> static constexpr intmax_t den = type::den;
> };
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_add<_R1, _R2>::num;
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_add<_R1, _R2>::den;
>
>
> template<typename _R1, typename _R2>
> using ratio_add = typename __ratio_add<_R1, _R2>::type;
>
> template<typename _R1, typename _R2>
> struct __ratio_subtract
> {
> typedef typename __ratio_add<
> _R1,
> ratio<-_R2::num, _R2::den>>::type type;
>
> static constexpr intmax_t num = type::num;
> static constexpr intmax_t den = type::den;
> };
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_subtract<_R1, _R2>::num;
>
> template<typename _R1, typename _R2>
> constexpr intmax_t __ratio_subtract<_R1, _R2>::den;
>
>
> template<typename _R1, typename _R2>
> using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
>
>
> typedef ratio<1, 1000000000000000000> atto;
> typedef ratio<1, 1000000000000000> femto;
> typedef ratio<1, 1000000000000> pico;
> typedef ratio<1, 1000000000> nano;
> typedef ratio<1, 1000000> micro;
> typedef ratio<1, 1000> milli;
> typedef ratio<1, 100> centi;
> typedef ratio<1, 10> deci;
> typedef ratio< 10, 1> deca;
> typedef ratio< 100, 1> hecto;
> typedef ratio< 1000, 1> kilo;
> typedef ratio< 1000000, 1> mega;
> typedef ratio< 1000000000, 1> giga;
> typedef ratio< 1000000000000, 1> tera;
> typedef ratio< 1000000000000000, 1> peta;
> typedef ratio< 1000000000000000000, 1> exa;
>
>
>
>}
># 39 "/usr/include/c++/8/chrono" 2 3
>
>
># 1 "/usr/include/c++/8/ctime" 1 3
># 39 "/usr/include/c++/8/ctime" 3
> 
># 40 "/usr/include/c++/8/ctime" 3
># 58 "/usr/include/c++/8/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;
>}
># 42 "/usr/include/c++/8/chrono" 2 3
># 1 "/usr/include/c++/8/bits/parse_numbers.h" 1 3
># 33 "/usr/include/c++/8/bits/parse_numbers.h" 3
> 
># 34 "/usr/include/c++/8/bits/parse_numbers.h" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>namespace __parse_int
>{
> template<unsigned _Base, char _Dig>
> struct _Digit;
>
> template<unsigned _Base>
> struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
> {
> using __valid = true_type;
> };
>
> template<unsigned _Base>
> struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
> {
> using __valid = true_type;
> };
>
> template<unsigned _Base, unsigned _Val>
> struct _Digit_impl : integral_constant<unsigned, _Val>
> {
> static_assert(_Base > _Val, "invalid digit");
> using __valid = true_type;
> };
>
> template<unsigned _Base>
> struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
> { };
>
> template<unsigned _Base>
> struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
> { };
>
>
> template<unsigned _Base>
> struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
> {
> using __valid = false_type;
> };
>
>
>
> template<unsigned long long _Val>
> using __ull_constant = integral_constant<unsigned long long, _Val>;
>
> template<unsigned _Base, char _Dig, char... _Digs>
> struct _Power_help
> {
> using __next = typename _Power_help<_Base, _Digs...>::type;
> using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
> using type
> = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
> };
>
> template<unsigned _Base, char _Dig>
> struct _Power_help<_Base, _Dig>
> {
> using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
> using type = __ull_constant<__valid_digit::value>;
> };
>
> template<unsigned _Base, char... _Digs>
> struct _Power : _Power_help<_Base, _Digs...>::type
> { };
>
> template<unsigned _Base>
> struct _Power<_Base> : __ull_constant<0>
> { };
>
>
>
> template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
> struct _Number_help
> {
> using __digit = _Digit<_Base, _Dig>;
> using __valid_digit = typename __digit::__valid;
> using __next = _Number_help<_Base,
> __valid_digit::value ? _Pow / _Base : _Pow,
> _Digs...>;
> using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
> static_assert((type::value / _Pow) == __digit::value,
> "integer literal does not fit in unsigned long long");
> };
>
>
> template<unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs>
> struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...>
> : _Number_help<_Base, _Pow, _Dig, _Digs...>
> { };
>
>
> template<unsigned _Base, char _Dig>
> struct _Number_help<_Base, 1ULL, _Dig>
> {
> using type = __ull_constant<_Digit<_Base, _Dig>::value>;
> };
>
> template<unsigned _Base, char... _Digs>
> struct _Number
> : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
> { };
>
> template<unsigned _Base>
> struct _Number<_Base>
> : __ull_constant<0>
> { };
>
>
>
> template<char... _Digs>
> struct _Parse_int;
>
> template<char... _Digs>
> struct _Parse_int<'0', 'b', _Digs...>
> : _Number<2U, _Digs...>::type
> { };
>
> template<char... _Digs>
> struct _Parse_int<'0', 'B', _Digs...>
> : _Number<2U, _Digs...>::type
> { };
>
> template<char... _Digs>
> struct _Parse_int<'0', 'x', _Digs...>
> : _Number<16U, _Digs...>::type
> { };
>
> template<char... _Digs>
> struct _Parse_int<'0', 'X', _Digs...>
> : _Number<16U, _Digs...>::type
> { };
>
> template<char... _Digs>
> struct _Parse_int<'0', _Digs...>
> : _Number<8U, _Digs...>::type
> { };
>
> template<char... _Digs>
> struct _Parse_int
> : _Number<10U, _Digs...>::type
> { };
>
>}
>
>
>namespace __select_int
>{
> template<unsigned long long _Val, typename... _Ints>
> struct _Select_int_base;
>
> template<unsigned long long _Val, typename _IntType, typename... _Ints>
> struct _Select_int_base<_Val, _IntType, _Ints...>
> : conditional_t<(_Val <= std::numeric_limits<_IntType>::max()),
> integral_constant<_IntType, _Val>,
> _Select_int_base<_Val, _Ints...>>
> { };
>
> template<unsigned long long _Val>
> struct _Select_int_base<_Val>
> { };
>
> template<char... _Digs>
> using _Select_int = typename _Select_int_base<
> __parse_int::_Parse_int<_Digs...>::value,
> unsigned char,
> unsigned short,
> unsigned int,
> unsigned long,
> unsigned long long
> >::type;
>
>}
>
>
>}
># 43 "/usr/include/c++/8/chrono" 2 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 61 "/usr/include/c++/8/chrono" 3
> namespace chrono
> {
> template<typename _Rep, typename _Period = ratio<1>>
> struct duration;
>
> template<typename _Clock, typename _Dur = typename _Clock::duration>
> struct time_point;
> }
>
>
>
> template<typename _CT, typename _Period1, typename _Period2>
> struct __duration_common_type_wrapper
> {
> private:
> typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
> typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
> typedef typename _CT::type __cr;
> typedef ratio<__gcd_num::value,
> (_Period1::den / __gcd_den::value) * _Period2::den> __r;
> public:
> typedef __success_type<chrono::duration<__cr, __r>> type;
> };
>
> template<typename _Period1, typename _Period2>
> struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
> { typedef __failure_type type; };
>
> template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
> struct common_type<chrono::duration<_Rep1, _Period1>,
> chrono::duration<_Rep2, _Period2>>
> : public __duration_common_type_wrapper<typename __member_type_wrapper<
> common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
> { };
>
>
>
> template<typename _CT, typename _Clock>
> struct __timepoint_common_type_wrapper
> {
> typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
> type;
> };
>
> template<typename _Clock>
> struct __timepoint_common_type_wrapper<__failure_type, _Clock>
> { typedef __failure_type type; };
>
> template<typename _Clock, typename _Duration1, typename _Duration2>
> struct common_type<chrono::time_point<_Clock, _Duration1>,
> chrono::time_point<_Clock, _Duration2>>
> : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
> common_type<_Duration1, _Duration2>>::type, _Clock>::type
> { };
>
> namespace chrono
> {
>
> template<typename _ToDur, typename _CF, typename _CR,
> bool _NumIsOne = false, bool _DenIsOne = false>
> struct __duration_cast_impl
> {
> template<typename _Rep, typename _Period>
> static constexpr _ToDur
> __cast(const duration<_Rep, _Period>& __d)
> {
> typedef typename _ToDur::rep __to_rep;
> return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
> * static_cast<_CR>(_CF::num)
> / static_cast<_CR>(_CF::den)));
> }
> };
>
> template<typename _ToDur, typename _CF, typename _CR>
> struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
> {
> template<typename _Rep, typename _Period>
> static constexpr _ToDur
> __cast(const duration<_Rep, _Period>& __d)
> {
> typedef typename _ToDur::rep __to_rep;
> return _ToDur(static_cast<__to_rep>(__d.count()));
> }
> };
>
> template<typename _ToDur, typename _CF, typename _CR>
> struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
> {
> template<typename _Rep, typename _Period>
> static constexpr _ToDur
> __cast(const duration<_Rep, _Period>& __d)
> {
> typedef typename _ToDur::rep __to_rep;
> return _ToDur(static_cast<__to_rep>(
> static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
> }
> };
>
> template<typename _ToDur, typename _CF, typename _CR>
> struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
> {
> template<typename _Rep, typename _Period>
> static constexpr _ToDur
> __cast(const duration<_Rep, _Period>& __d)
> {
> typedef typename _ToDur::rep __to_rep;
> return _ToDur(static_cast<__to_rep>(
> static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
> }
> };
>
> template<typename _Tp>
> struct __is_duration
> : std::false_type
> { };
>
> template<typename _Rep, typename _Period>
> struct __is_duration<duration<_Rep, _Period>>
> : std::true_type
> { };
>
> template<typename _Tp>
> using __enable_if_is_duration
> = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;
>
> template<typename _Tp>
> using __disable_if_is_duration
> = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;
>
>
> template<typename _ToDur, typename _Rep, typename _Period>
> constexpr __enable_if_is_duration<_ToDur>
> duration_cast(const duration<_Rep, _Period>& __d)
> {
> typedef typename _ToDur::period __to_period;
> typedef typename _ToDur::rep __to_rep;
> typedef ratio_divide<_Period, __to_period> __cf;
> typedef typename common_type<__to_rep, _Rep, intmax_t>::type
> __cr;
> typedef __duration_cast_impl<_ToDur, __cf, __cr,
> __cf::num == 1, __cf::den == 1> __dc;
> return __dc::__cast(__d);
> }
>
>
> template<typename _Rep>
> struct treat_as_floating_point
> : is_floating_point<_Rep>
> { };
>
>
> template <typename _Rep>
> inline constexpr bool treat_as_floating_point_v =
> treat_as_floating_point<_Rep>::value;
>
>
>
>
>
> template<typename _ToDur, typename _Rep, typename _Period>
> constexpr __enable_if_is_duration<_ToDur>
> floor(const duration<_Rep, _Period>& __d)
> {
> auto __to = chrono::duration_cast<_ToDur>(__d);
> if (__to > __d)
> return __to - _ToDur{1};
> return __to;
> }
>
> template<typename _ToDur, typename _Rep, typename _Period>
> constexpr __enable_if_is_duration<_ToDur>
> ceil(const duration<_Rep, _Period>& __d)
> {
> auto __to = chrono::duration_cast<_ToDur>(__d);
> if (__to < __d)
> return __to + _ToDur{1};
> return __to;
> }
>
> template <typename _ToDur, typename _Rep, typename _Period>
> constexpr enable_if_t<
> __and_<__is_duration<_ToDur>,
> __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
> _ToDur>
> round(const duration<_Rep, _Period>& __d)
> {
> _ToDur __t0 = chrono::floor<_ToDur>(__d);
> _ToDur __t1 = __t0 + _ToDur{1};
> auto __diff0 = __d - __t0;
> auto __diff1 = __t1 - __d;
> if (__diff0 == __diff1)
> {
> if (__t0.count() & 1)
> return __t1;
> return __t0;
> }
> else if (__diff0 < __diff1)
> return __t0;
> return __t1;
> }
>
> template<typename _Rep, typename _Period>
> constexpr
> enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
> abs(duration<_Rep, _Period> __d)
> {
> if (__d >= __d.zero())
> return __d;
> return -__d;
> }
>
>
>
> template<typename _Rep>
> struct duration_values
> {
> static constexpr _Rep
> zero()
> { return _Rep(0); }
>
> static constexpr _Rep
> max()
> { return numeric_limits<_Rep>::max(); }
>
> static constexpr _Rep
> min()
> { return numeric_limits<_Rep>::lowest(); }
> };
>
> template<typename _Tp>
> struct __is_ratio
> : std::false_type
> { };
>
> template<intmax_t _Num, intmax_t _Den>
> struct __is_ratio<ratio<_Num, _Den>>
> : std::true_type
> { };
>
>
> template<typename _Rep, typename _Period>
> struct duration
> {
> private:
> template<typename _Rep2>
> using __is_float = treat_as_floating_point<_Rep2>;
>
>
> template<typename _Period2>
> using __is_harmonic
> = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>;
>
> public:
>
> typedef _Rep rep;
> typedef _Period period;
>
> static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
> static_assert(__is_ratio<_Period>::value,
> "period must be a specialization of ratio");
> static_assert(_Period::num > 0, "period must be positive");
>
>
> constexpr duration() = default;
>
> duration(const duration&) = default;
>
> template<typename _Rep2, typename = _Require<
> is_convertible<_Rep2, rep>,
> __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
> constexpr explicit duration(const _Rep2& __rep)
> : __r(static_cast<rep>(__rep)) { }
>
> template<typename _Rep2, typename _Period2, typename = _Require<
> __or_<__is_float<rep>,
> __and_<__is_harmonic<_Period2>,
> __not_<__is_float<_Rep2>>>>>>
> constexpr duration(const duration<_Rep2, _Period2>& __d)
> : __r(duration_cast<duration>(__d).count()) { }
>
> ~duration() = default;
> duration& operator=(const duration&) = default;
>
>
> constexpr rep
> count() const
> { return __r; }
>
>
> constexpr duration
> operator+() const
> { return *this; }
>
> constexpr duration
> operator-() const
> { return duration(-__r); }
>
> constexpr duration&
> operator++()
> {
> ++__r;
> return *this;
> }
>
> constexpr duration
> operator++(int)
> { return duration(__r++); }
>
> constexpr duration&
> operator--()
> {
> --__r;
> return *this;
> }
>
> constexpr duration
> operator--(int)
> { return duration(__r--); }
>
> constexpr duration&
> operator+=(const duration& __d)
> {
> __r += __d.count();
> return *this;
> }
>
> constexpr duration&
> operator-=(const duration& __d)
> {
> __r -= __d.count();
> return *this;
> }
>
> constexpr duration&
> operator*=(const rep& __rhs)
> {
> __r *= __rhs;
> return *this;
> }
>
> constexpr duration&
> operator/=(const rep& __rhs)
> {
> __r /= __rhs;
> return *this;
> }
>
>
> template<typename _Rep2 = rep>
> constexpr
> typename enable_if<!treat_as_floating_point<_Rep2>::value,
> duration&>::type
> operator%=(const rep& __rhs)
> {
> __r %= __rhs;
> return *this;
> }
>
> template<typename _Rep2 = rep>
> constexpr
> typename enable_if<!treat_as_floating_point<_Rep2>::value,
> duration&>::type
> operator%=(const duration& __d)
> {
> __r %= __d.count();
> return *this;
> }
>
>
> static constexpr duration
> zero()
> { return duration(duration_values<rep>::zero()); }
>
> static constexpr duration
> min()
> { return duration(duration_values<rep>::min()); }
>
> static constexpr duration
> max()
> { return duration(duration_values<rep>::max()); }
>
> 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());
> }
>
>
>
> template<typename _Rep1, typename _Rep2,
> typename _CRep = typename common_type<_Rep1, _Rep2>::type>
> using __common_rep_t
> = typename enable_if<is_convertible<_Rep2, _CRep>::value, _CRep>::type;
>
> template<typename _Rep1, typename _Period, typename _Rep2>
> constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
> operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
> {
> typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
> __cd;
> return __cd(__cd(__d).count() * __s);
> }
>
> template<typename _Rep1, typename _Rep2, typename _Period>
> constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
> operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
> { return __d * __s; }
>
> template<typename _Rep1, typename _Period, typename _Rep2>
> constexpr
> duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
> operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
> {
> typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
> __cd;
> return __cd(__cd(__d).count() / __s);
> }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr typename common_type<_Rep1, _Rep2>::type
> operator/(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> {
> typedef duration<_Rep1, _Period1> __dur1;
> typedef duration<_Rep2, _Period2> __dur2;
> typedef typename common_type<__dur1,__dur2>::type __cd;
> return __cd(__lhs).count() / __cd(__rhs).count();
> }
>
>
> template<typename _Rep1, typename _Period, typename _Rep2>
> constexpr
> duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
> operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
> {
> typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
> __cd;
> return __cd(__cd(__d).count() % __s);
> }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr typename common_type<duration<_Rep1, _Period1>,
> duration<_Rep2, _Period2>>::type
> operator%(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> {
> typedef duration<_Rep1, _Period1> __dur1;
> typedef duration<_Rep2, _Period2> __dur2;
> typedef typename common_type<__dur1,__dur2>::type __cd;
> return __cd(__cd(__lhs).count() % __cd(__rhs).count());
> }
>
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr bool
> operator==(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> {
> typedef duration<_Rep1, _Period1> __dur1;
> typedef duration<_Rep2, _Period2> __dur2;
> typedef typename common_type<__dur1,__dur2>::type __ct;
> return __ct(__lhs).count() == __ct(__rhs).count();
> }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr bool
> operator<(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> {
> typedef duration<_Rep1, _Period1> __dur1;
> typedef duration<_Rep2, _Period2> __dur2;
> typedef typename common_type<__dur1,__dur2>::type __ct;
> return __ct(__lhs).count() < __ct(__rhs).count();
> }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr bool
> operator!=(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> { return !(__lhs == __rhs); }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr bool
> operator<=(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> { return !(__rhs < __lhs); }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr bool
> operator>(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> { return __rhs < __lhs; }
>
> template<typename _Rep1, typename _Period1,
> typename _Rep2, typename _Period2>
> constexpr bool
> operator>=(const duration<_Rep1, _Period1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> { return !(__lhs < __rhs); }
>
>
> typedef duration<int64_t, nano> nanoseconds;
>
>
> typedef duration<int64_t, micro> microseconds;
>
>
> typedef duration<int64_t, milli> milliseconds;
>
>
> typedef duration<int64_t> seconds;
>
>
> typedef duration<int64_t, ratio< 60>> minutes;
>
>
> typedef duration<int64_t, ratio<3600>> hours;
>
>
> template<typename _Clock, typename _Dur>
> struct time_point
> {
> typedef _Clock clock;
> typedef _Dur duration;
> typedef typename duration::rep rep;
> typedef typename duration::period period;
>
> constexpr time_point() : __d(duration::zero())
> { }
>
> constexpr explicit time_point(const duration& __dur)
> : __d(__dur)
> { }
>
>
> template<typename _Dur2,
> typename = _Require<is_convertible<_Dur2, _Dur>>>
> constexpr time_point(const time_point<clock, _Dur2>& __t)
> : __d(__t.time_since_epoch())
> { }
>
>
> constexpr duration
> time_since_epoch() const
> { return __d; }
>
>
> constexpr time_point&
> operator+=(const duration& __dur)
> {
> __d += __dur;
> return *this;
> }
>
> constexpr time_point&
> operator-=(const duration& __dur)
> {
> __d -= __dur;
> return *this;
> }
>
>
> static constexpr time_point
> min()
> { return time_point(duration::min()); }
>
> static constexpr time_point
> max()
> { return time_point(duration::max()); }
>
> private:
> duration __d;
> };
>
>
> template<typename _ToDur, typename _Clock, typename _Dur>
> constexpr typename enable_if<__is_duration<_ToDur>::value,
> time_point<_Clock, _ToDur>>::type
> time_point_cast(const time_point<_Clock, _Dur>& __t)
> {
> typedef time_point<_Clock, _ToDur> __time_point;
> return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
> }
>
>
> template<typename _ToDur, typename _Clock, typename _Dur>
> constexpr
> enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
> floor(const time_point<_Clock, _Dur>& __tp)
> {
> return time_point<_Clock, _ToDur>{
> chrono::floor<_ToDur>(__tp.time_since_epoch())};
> }
>
> template<typename _ToDur, typename _Clock, typename _Dur>
> constexpr
> enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
> ceil(const time_point<_Clock, _Dur>& __tp)
> {
> return time_point<_Clock, _ToDur>{
> chrono::ceil<_ToDur>(__tp.time_since_epoch())};
> }
>
> template<typename _ToDur, typename _Clock, typename _Dur>
> constexpr enable_if_t<
> __and_<__is_duration<_ToDur>,
> __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
> time_point<_Clock, _ToDur>>
> round(const time_point<_Clock, _Dur>& __tp)
> {
> return time_point<_Clock, _ToDur>{
> chrono::round<_ToDur>(__tp.time_since_epoch())};
> }
>
>
> template<typename _Clock, typename _Dur1,
> typename _Rep2, typename _Period2>
> constexpr time_point<_Clock,
> typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
> operator+(const time_point<_Clock, _Dur1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> {
> typedef duration<_Rep2, _Period2> __dur2;
> typedef typename common_type<_Dur1,__dur2>::type __ct;
> typedef time_point<_Clock, __ct> __time_point;
> return __time_point(__lhs.time_since_epoch() + __rhs);
> }
>
> template<typename _Rep1, typename _Period1,
> typename _Clock, typename _Dur2>
> constexpr time_point<_Clock,
> typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
> operator+(const duration<_Rep1, _Period1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> {
> typedef duration<_Rep1, _Period1> __dur1;
> typedef typename common_type<__dur1,_Dur2>::type __ct;
> typedef time_point<_Clock, __ct> __time_point;
> return __time_point(__rhs.time_since_epoch() + __lhs);
> }
>
> template<typename _Clock, typename _Dur1,
> typename _Rep2, typename _Period2>
> constexpr time_point<_Clock,
> typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
> operator-(const time_point<_Clock, _Dur1>& __lhs,
> const duration<_Rep2, _Period2>& __rhs)
> {
> typedef duration<_Rep2, _Period2> __dur2;
> typedef typename common_type<_Dur1,__dur2>::type __ct;
> typedef time_point<_Clock, __ct> __time_point;
> return __time_point(__lhs.time_since_epoch() -__rhs);
> }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr typename common_type<_Dur1, _Dur2>::type
> operator-(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr bool
> operator==(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr bool
> operator!=(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return !(__lhs == __rhs); }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr bool
> operator<(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr bool
> operator<=(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return !(__rhs < __lhs); }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr bool
> operator>(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return __rhs < __lhs; }
>
> template<typename _Clock, typename _Dur1, typename _Dur2>
> constexpr bool
> operator>=(const time_point<_Clock, _Dur1>& __lhs,
> const time_point<_Clock, _Dur2>& __rhs)
> { return !(__lhs < __rhs); }
># 807 "/usr/include/c++/8/chrono" 3
> inline namespace _V2 {
>
>
>
>
>
>
> struct system_clock
> {
> typedef chrono::nanoseconds duration;
> typedef duration::rep rep;
> typedef duration::period period;
> typedef chrono::time_point<system_clock, duration> time_point;
>
> static_assert(system_clock::duration::min()
> < system_clock::duration::zero(),
> "a clock's minimum duration cannot be less than its epoch");
>
> static constexpr bool is_steady = false;
>
> static time_point
> now() noexcept;
>
>
> static std::time_t
> to_time_t(const time_point& __t) noexcept
> {
> return std::time_t(duration_cast<chrono::seconds>
> (__t.time_since_epoch()).count());
> }
>
> static time_point
> from_time_t(std::time_t __t) noexcept
> {
> typedef chrono::time_point<system_clock, seconds> __from;
> return time_point_cast<system_clock::duration>
> (__from(chrono::seconds(__t)));
> }
> };
>
>
>
>
>
>
>
> 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;
> };
># 874 "/usr/include/c++/8/chrono" 3
> using high_resolution_clock = system_clock;
>
> }
> }
>
>
>
>
>
> inline namespace literals
> {
> inline namespace chrono_literals
> {
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wliteral-suffix"
> template<typename _Rep, unsigned long long _Val>
> struct _Checked_integral_constant
> : integral_constant<_Rep, static_cast<_Rep>(_Val)>
> {
> static_assert(_Checked_integral_constant::value >= 0
> && _Checked_integral_constant::value == _Val,
> "literal value cannot be represented by duration type");
> };
>
> template<typename _Dur, char... _Digits>
> constexpr _Dur __check_overflow()
> {
> using _Val = __parse_int::_Parse_int<_Digits...>;
> using _Rep = typename _Dur::rep;
>
>
> using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>;
> return _Dur{_CheckedVal::value};
> }
>
> 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;
> }
>
>
>
>
>
>
>}
># 22 "/usr/include/boost/asio/detail/chrono.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace chrono {
>
>
>using std::chrono::duration;
>using std::chrono::time_point;
>using std::chrono::duration_cast;
>using std::chrono::nanoseconds;
>using std::chrono::microseconds;
>using std::chrono::milliseconds;
>using std::chrono::seconds;
>using std::chrono::minutes;
>using std::chrono::hours;
>using std::chrono::time_point_cast;
>
>
>
>using std::chrono::steady_clock;
>
>using std::chrono::system_clock;
>using std::chrono::high_resolution_clock;
># 64 "/usr/include/boost/asio/detail/chrono.hpp" 3 4
>}
>}
>}
># 30 "/usr/include/boost/asio/io_context.hpp" 2 3 4
># 39 "/usr/include/boost/asio/io_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 40 "/usr/include/boost/asio/io_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>
>
>
> typedef class scheduler io_context_impl;
>
>}
># 179 "/usr/include/boost/asio/io_context.hpp" 3 4
>class io_context
> : public execution_context
>{
>private:
> typedef detail::io_context_impl impl_type;
>
>
>
>
>public:
> class executor_type;
> friend class executor_type;
>
>
> class work;
> friend class work;
>
>
> class service;
>
>
> class strand;
>
>
>
> typedef std::size_t count_type;
>
>
> inline io_context();
># 216 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline explicit io_context(int concurrency_hint);
># 250 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline ~io_context();
>
>
> executor_type get_executor() noexcept;
># 280 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type run();
># 311 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type run(boost::system::error_code& ec);
># 326 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Rep, typename Period>
> std::size_t run_for(const chrono::duration<Rep, Period>& rel_time);
># 339 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Clock, typename Duration>
> std::size_t run_until(const chrono::time_point<Clock, Duration>& abs_time);
># 360 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type run_one();
># 382 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type run_one(boost::system::error_code& ec);
># 397 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Rep, typename Period>
> std::size_t run_one_for(const chrono::duration<Rep, Period>& rel_time);
># 411 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Clock, typename Duration>
> std::size_t run_one_until(
> const chrono::time_point<Clock, Duration>& abs_time);
># 424 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type poll();
># 437 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type poll(boost::system::error_code& ec);
># 448 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type poll_one();
># 461 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline count_type poll_one(boost::system::error_code& ec);
># 471 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline void stop();
># 483 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline bool stopped() const;
># 496 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline void restart();
># 511 "/usr/include/boost/asio/io_context.hpp" 3 4
> void reset();
># 535 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void ()>::return_type
> dispatch(CompletionHandler&& handler);
># 562 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void ()>::return_type
> post(CompletionHandler&& handler);
># 588 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Handler>
>
>
>
> detail::wrapped_handler<io_context&, Handler>
>
> wrap(Handler handler);
>
>
>private:
>
> inline impl_type& add_impl(impl_type* impl);
>
>
>
> template <typename Service>
> friend Service& use_service(io_context& ioc);
># 614 "/usr/include/boost/asio/io_context.hpp" 3 4
> impl_type& impl_;
>};
>
>
>class io_context::executor_type
>{
>public:
>
> io_context& context() const noexcept;
>
>
>
>
>
>
>
> void on_work_started() const noexcept;
>
>
>
>
>
>
>
> void on_work_finished() const noexcept;
># 654 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Function, typename Allocator>
> void dispatch(Function&& f, const Allocator& a) const;
># 670 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Function, typename Allocator>
> void post(Function&& f, const Allocator& a) const;
># 690 "/usr/include/boost/asio/io_context.hpp" 3 4
> template <typename Function, typename Allocator>
> void defer(Function&& f, const Allocator& a) const;
>
>
>
>
>
>
> bool running_in_this_thread() const noexcept;
>
>
>
>
>
> friend bool operator==(const executor_type& a,
> const executor_type& b) noexcept
> {
> return &a.io_context_ == &b.io_context_;
> }
>
>
>
>
>
> friend bool operator!=(const executor_type& a,
> const executor_type& b) noexcept
> {
> return &a.io_context_ != &b.io_context_;
> }
>
>private:
> friend class io_context;
>
>
> explicit executor_type(io_context& i) : io_context_(i) {}
>
>
> io_context& io_context_;
>};
># 742 "/usr/include/boost/asio/io_context.hpp" 3 4
>class io_context::work
>{
>public:
>
>
>
>
>
>
> explicit work(boost::asio::io_context& io_context);
>
>
>
>
>
>
>
> work(const work& other);
>
>
>
>
>
>
>
> ~work();
>
>
> boost::asio::io_context& get_io_context();
>
>
>
> boost::asio::io_context& get_io_service();
>
>private:
>
> void operator=(const work& other);
>
>
> detail::io_context_impl& io_context_impl_;
>};
>
>
>
>class io_context::service
> : public execution_context::service
>{
>public:
>
> boost::asio::io_context& get_io_context();
>
>
>
> boost::asio::io_context& get_io_service();
>
>
>private:
>
> inline virtual void shutdown();
>
>
>
>
> inline virtual void shutdown_service();
># 814 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline virtual void notify_fork(
> execution_context::fork_event event);
># 824 "/usr/include/boost/asio/io_context.hpp" 3 4
> inline virtual void fork_service(
> execution_context::fork_event event);
>
>
>protected:
>
>
>
>
> inline service(boost::asio::io_context& owner);
>
>
> inline virtual ~service();
>};
>
>namespace detail {
>
>
>template <typename Type>
>class service_base
> : public boost::asio::io_context::service
>{
>public:
> static boost::asio::detail::service_id<Type> id;
>
>
> service_base(boost::asio::io_context& io_context)
> : boost::asio::io_context::service(io_context)
> {
> }
>};
>
>template <typename Type>
>boost::asio::detail::service_id<Type> service_base<Type>::id;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 864 "/usr/include/boost/asio/io_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/io_context.hpp" 1 3 4
># 18 "/usr/include/boost/asio/impl/io_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/completion_handler.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/completion_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/handler_work.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/handler_work.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/handler_work.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>template <typename Handler, typename Executor
> = typename associated_executor<Handler>::type>
>class handler_work
>{
>public:
> explicit handler_work(Handler& handler) noexcept
> : executor_(associated_executor<Handler>::get(handler))
> {
> }
>
> static void start(Handler& handler) noexcept
> {
> Executor ex(associated_executor<Handler>::get(handler));
> ex.on_work_started();
> }
>
> ~handler_work()
> {
> executor_.on_work_finished();
> }
>
> template <typename Function>
> void complete(Function& function, Handler& handler)
> {
> executor_.dispatch(static_cast<Function&&>(function),
> associated_allocator<Handler>::get(handler));
> }
>
>private:
>
> handler_work(const handler_work&);
> handler_work& operator=(const handler_work&);
>
> typename associated_executor<Handler>::type executor_;
>};
>
>
>
>
>
>template <typename Handler>
>class handler_work<Handler, system_executor>
>{
>public:
> explicit handler_work(Handler&) noexcept {}
> static void start(Handler&) noexcept {}
> ~handler_work() {}
>
> template <typename Function>
> void complete(Function& function, Handler& handler)
> {
> boost_asio_handler_invoke_helpers::invoke(function, handler);
> }
>
>private:
>
> handler_work(const handler_work&);
> handler_work& operator=(const handler_work&);
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 96 "/usr/include/boost/asio/detail/handler_work.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class completion_handler : public operation
>{
>public:
> struct ptr { Handler* h; completion_handler* v; completion_handler* p; ~ptr() { reset(); } static completion_handler* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<completion_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~completion_handler(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<completion_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<completion_handler*>(v), 1); v = 0; } } };
>
> completion_handler(Handler& h)
> : operation(&completion_handler::do_complete),
> handler_(static_cast<Handler&&>(h))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> completion_handler* h(static_cast<completion_handler*>(base));
> ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
> handler_work<Handler> w(h->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> Handler handler(static_cast<Handler&&>(h->handler_));
> p.h = boost::asio::detail::addressof(handler);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 84 "/usr/include/boost/asio/detail/completion_handler.hpp" 2 3 4
># 19 "/usr/include/boost/asio/impl/io_context.hpp" 2 3 4
># 27 "/usr/include/boost/asio/impl/io_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/impl/io_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename Service>
>inline Service& use_service(io_context& ioc)
>{
>
> (void)static_cast<execution_context::service*>(static_cast<Service*>(0));
> (void)static_cast<const execution_context::id*>(&Service::id);
>
> return ioc.service_registry_->template use_service<Service>(ioc);
>}
>
>template <>
>inline detail::io_context_impl& use_service<detail::io_context_impl>(
> io_context& ioc)
>{
> return ioc.impl_;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 53 "/usr/include/boost/asio/impl/io_context.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 61 "/usr/include/boost/asio/impl/io_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>inline io_context::executor_type
>io_context::get_executor() noexcept
>{
> return executor_type(*this);
>}
>
>
>
>template <typename Rep, typename Period>
>std::size_t io_context::run_for(
> const chrono::duration<Rep, Period>& rel_time)
>{
> return this->run_until(chrono::steady_clock::now() + rel_time);
>}
>
>template <typename Clock, typename Duration>
>std::size_t io_context::run_until(
> const chrono::time_point<Clock, Duration>& abs_time)
>{
> std::size_t n = 0;
> while (this->run_one_until(abs_time))
> if (n != (std::numeric_limits<std::size_t>::max)())
> ++n;
> return n;
>}
>
>template <typename Rep, typename Period>
>std::size_t io_context::run_one_for(
> const chrono::duration<Rep, Period>& rel_time)
>{
> return this->run_one_until(chrono::steady_clock::now() + rel_time);
>}
>
>template <typename Clock, typename Duration>
>std::size_t io_context::run_one_until(
> const chrono::time_point<Clock, Duration>& abs_time)
>{
> typename Clock::time_point now = Clock::now();
> while (now < abs_time)
> {
> typename Clock::duration rel_time = abs_time - now;
> if (rel_time > chrono::seconds(1))
> rel_time = chrono::seconds(1);
>
> boost::system::error_code ec;
> std::size_t s = impl_.wait_one(
> static_cast<long>(chrono::duration_cast<
> chrono::microseconds>(rel_time).count()), ec);
> boost::asio::detail::throw_error(ec);
>
> if (s || impl_.stopped())
> return s;
>
> now = Clock::now();
> }
>
> return 0;
>}
>
>
>
>
>
>inline void io_context::reset()
>{
> restart();
>}
>
>template <typename CompletionHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void ()>::return_type
>io_context::dispatch(CompletionHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<CompletionHandler, void ()> init(handler);
>
> if (impl_.can_dispatch())
> {
> detail::fenced_block b(detail::fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(
> init.completion_handler, init.completion_handler);
> }
> else
> {
>
> typedef detail::completion_handler<
> typename handler_type<CompletionHandler, void ()>::type> op;
> typename op::ptr p = { detail::addressof(init.completion_handler),
> op::ptr::allocate(init.completion_handler), 0 };
> p.p = new (p.v) op(init.completion_handler);
>
> (void)0
> ;
>
> impl_.do_dispatch(p.p);
> p.v = p.p = 0;
> }
>
> return init.result.get();
>}
>
>template <typename CompletionHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void ()>::return_type
>io_context::post(CompletionHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<CompletionHandler, void ()> init(handler);
>
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(init.completion_handler);
>
>
> typedef detail::completion_handler<
> typename handler_type<CompletionHandler, void ()>::type> op;
> typename op::ptr p = { detail::addressof(init.completion_handler),
> op::ptr::allocate(init.completion_handler), 0 };
> p.p = new (p.v) op(init.completion_handler);
>
> (void)0
> ;
>
> impl_.post_immediate_completion(p.p, is_continuation);
> p.v = p.p = 0;
>
> return init.result.get();
>}
>
>template <typename Handler>
>
>
>
>inline detail::wrapped_handler<io_context&, Handler>
>
>io_context::wrap(Handler handler)
>{
> return detail::wrapped_handler<io_context&, Handler>(*this, handler);
>}
>
>
>
>inline io_context&
>io_context::executor_type::context() const noexcept
>{
> return io_context_;
>}
>
>inline void
>io_context::executor_type::on_work_started() const noexcept
>{
> io_context_.impl_.work_started();
>}
>
>inline void
>io_context::executor_type::on_work_finished() const noexcept
>{
> io_context_.impl_.work_finished();
>}
>
>template <typename Function, typename Allocator>
>void io_context::executor_type::dispatch(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
>
> if (io_context_.impl_.can_dispatch())
> {
>
> function_type tmp(static_cast<Function&&>(f));
>
> detail::fenced_block b(detail::fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
> return;
> }
>
>
> typedef detail::executor_op<function_type, Allocator, detail::operation> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> io_context_.impl_.post_immediate_completion(p.p, false);
> p.v = p.p = 0;
>}
>
>template <typename Function, typename Allocator>
>void io_context::executor_type::post(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
>
> typedef detail::executor_op<function_type, Allocator, detail::operation> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> io_context_.impl_.post_immediate_completion(p.p, false);
> p.v = p.p = 0;
>}
>
>template <typename Function, typename Allocator>
>void io_context::executor_type::defer(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
>
> typedef detail::executor_op<function_type, Allocator, detail::operation> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> io_context_.impl_.post_immediate_completion(p.p, true);
> p.v = p.p = 0;
>}
>
>inline bool
>io_context::executor_type::running_in_this_thread() const noexcept
>{
> return io_context_.impl_.can_dispatch();
>}
>
>
>inline io_context::work::work(boost::asio::io_context& io_context)
> : io_context_impl_(io_context.impl_)
>{
> io_context_impl_.work_started();
>}
>
>inline io_context::work::work(const work& other)
> : io_context_impl_(other.io_context_impl_)
>{
> io_context_impl_.work_started();
>}
>
>inline io_context::work::~work()
>{
> io_context_impl_.work_finished();
>}
>
>inline boost::asio::io_context& io_context::work::get_io_context()
>{
> return static_cast<boost::asio::io_context&>(io_context_impl_.context());
>}
>
>inline boost::asio::io_context& io_context::work::get_io_service()
>{
> return static_cast<boost::asio::io_context&>(io_context_impl_.context());
>}
>
>
>inline boost::asio::io_context& io_context::service::get_io_context()
>{
> return static_cast<boost::asio::io_context&>(context());
>}
>
>
>inline boost::asio::io_context& io_context::service::get_io_service()
>{
> return static_cast<boost::asio::io_context&>(context());
>}
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 344 "/usr/include/boost/asio/impl/io_context.hpp" 2 3 4
># 866 "/usr/include/boost/asio/io_context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/io_context.ipp" 1 3 4
># 19 "/usr/include/boost/asio/impl/io_context.ipp" 3 4
># 1 "/usr/include/boost/asio/io_context.hpp" 1 3 4
># 20 "/usr/include/boost/asio/impl/io_context.ipp" 2 3 4
># 32 "/usr/include/boost/asio/impl/io_context.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 33 "/usr/include/boost/asio/impl/io_context.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>io_context::io_context()
> : impl_(add_impl(new impl_type(*this, -1)))
>{
>}
>
>io_context::io_context(int concurrency_hint)
> : impl_(add_impl(new impl_type(*this, concurrency_hint == 1
> ? 1 : concurrency_hint)))
>{
>}
>
>io_context::impl_type& io_context::add_impl(io_context::impl_type* impl)
>{
> boost::asio::detail::scoped_ptr<impl_type> scoped_impl(impl);
> boost::asio::add_service<impl_type>(*this, scoped_impl.get());
> return *scoped_impl.release();
>}
>
>io_context::~io_context()
>{
>}
>
>io_context::count_type io_context::run()
>{
> boost::system::error_code ec;
> count_type s = impl_.run(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>
>io_context::count_type io_context::run(boost::system::error_code& ec)
>{
> return impl_.run(ec);
>}
>
>
>io_context::count_type io_context::run_one()
>{
> boost::system::error_code ec;
> count_type s = impl_.run_one(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>
>io_context::count_type io_context::run_one(boost::system::error_code& ec)
>{
> return impl_.run_one(ec);
>}
>
>
>io_context::count_type io_context::poll()
>{
> boost::system::error_code ec;
> count_type s = impl_.poll(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>
>io_context::count_type io_context::poll(boost::system::error_code& ec)
>{
> return impl_.poll(ec);
>}
>
>
>io_context::count_type io_context::poll_one()
>{
> boost::system::error_code ec;
> count_type s = impl_.poll_one(ec);
> boost::asio::detail::throw_error(ec);
> return s;
>}
>
>
>io_context::count_type io_context::poll_one(boost::system::error_code& ec)
>{
> return impl_.poll_one(ec);
>}
>
>
>void io_context::stop()
>{
> impl_.stop();
>}
>
>bool io_context::stopped() const
>{
> return impl_.stopped();
>}
>
>void io_context::restart()
>{
> impl_.restart();
>}
>
>io_context::service::service(boost::asio::io_context& owner)
> : execution_context::service(owner)
>{
>}
>
>io_context::service::~service()
>{
>}
>
>void io_context::service::shutdown()
>{
>
> shutdown_service();
>
>}
>
>
>void io_context::service::shutdown_service()
>{
>}
>
>
>void io_context::service::notify_fork(io_context::fork_event ev)
>{
>
> fork_service(ev);
>
>
>
>}
>
>
>void io_context::service::fork_service(io_context::fork_event)
>{
>}
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 175 "/usr/include/boost/asio/impl/io_context.ipp" 2 3 4
># 868 "/usr/include/boost/asio/io_context.hpp" 2 3 4
># 20 "/usr/include/boost/asio/basic_io_object.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/basic_io_object.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>namespace detail
>{
>
> template <typename IoObjectService>
> class service_has_move
> {
> private:
> typedef IoObjectService service_type;
> typedef typename service_type::implementation_type implementation_type;
>
> template <typename T, typename U>
> static auto asio_service_has_move_eval(T* t, U* u)
> -> decltype(t->move_construct(*u, *u), char());
> static char (&asio_service_has_move_eval(...))[2];
>
> public:
> static const bool value =
> sizeof(asio_service_has_move_eval(
> static_cast<service_type*>(0),
> static_cast<implementation_type*>(0))) == 1;
> };
>}
># 59 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
>template <typename IoObjectService,
> bool Movable = detail::service_has_move<IoObjectService>::value>
>
>class basic_io_object
>{
>public:
>
> typedef IoObjectService service_type;
>
>
> typedef typename service_type::implementation_type implementation_type;
># 81 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return service_.get_io_context();
> }
># 95 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return service_.get_io_context();
> }
>
>
>
> typedef boost::asio::io_context::executor_type executor_type;
>
>
> executor_type get_executor() noexcept
> {
> return service_.get_io_context().get_executor();
> }
>
>protected:
>
>
>
>
>
> explicit basic_io_object(boost::asio::io_context& io_context)
> : service_(boost::asio::use_service<IoObjectService>(io_context))
> {
> service_.construct(implementation_);
> }
># 154 "/usr/include/boost/asio/basic_io_object.hpp" 3 4
> ~basic_io_object()
> {
> service_.destroy(implementation_);
> }
>
>
> service_type& get_service()
> {
> return service_;
> }
>
>
> const service_type& get_service() const
> {
> return service_;
> }
>
>
> implementation_type& get_implementation()
> {
> return implementation_;
> }
>
>
> const implementation_type& get_implementation() const
> {
> return implementation_;
> }
>
>private:
> basic_io_object(const basic_io_object&);
> basic_io_object& operator=(const basic_io_object&);
>
>
> service_type& service_;
>
>
> implementation_type implementation_;
>};
>
>
>
>template <typename IoObjectService>
>class basic_io_object<IoObjectService, true>
>{
>public:
> typedef IoObjectService service_type;
> typedef typename service_type::implementation_type implementation_type;
>
>
> boost::asio::io_context& get_io_context()
> {
> return service_->get_io_context();
> }
>
> boost::asio::io_context& get_io_service()
> {
> return service_->get_io_context();
> }
>
>
> typedef boost::asio::io_context::executor_type executor_type;
>
> executor_type get_executor() noexcept
> {
> return service_->get_io_context().get_executor();
> }
>
>protected:
> explicit basic_io_object(boost::asio::io_context& io_context)
> : service_(&boost::asio::use_service<IoObjectService>(io_context))
> {
> service_->construct(implementation_);
> }
>
> basic_io_object(basic_io_object&& other)
> : service_(&other.get_service())
> {
> service_->move_construct(implementation_, other.implementation_);
> }
>
> template <typename IoObjectService1>
> basic_io_object(IoObjectService1& other_service,
> typename IoObjectService1::implementation_type& other_implementation)
> : service_(&boost::asio::use_service<IoObjectService>(
> other_service.get_io_context()))
> {
> service_->converting_move_construct(implementation_,
> other_service, other_implementation);
> }
>
> ~basic_io_object()
> {
> service_->destroy(implementation_);
> }
>
> basic_io_object& operator=(basic_io_object&& other)
> {
> service_->move_assign(implementation_,
> *other.service_, other.implementation_);
> service_ = other.service_;
> return *this;
> }
>
> service_type& get_service()
> {
> return *service_;
> }
>
> const service_type& get_service() const
> {
> return *service_;
> }
>
> implementation_type& get_implementation()
> {
> return implementation_;
> }
>
> const implementation_type& get_implementation() const
> {
> return implementation_;
> }
>
>private:
> basic_io_object(const basic_io_object&);
> void operator=(const basic_io_object&);
>
> IoObjectService* service_;
> implementation_type implementation_;
>};
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 291 "/usr/include/boost/asio/basic_io_object.hpp" 2 3 4
># 21 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/post.hpp" 1 3 4
># 24 "/usr/include/boost/asio/post.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/post.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 53 "/usr/include/boost/asio/post.hpp" 3 4
>template <typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
> CompletionToken&& token);
># 87 "/usr/include/boost/asio/post.hpp" 3 4
>template <typename Executor, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
> const Executor& ex, CompletionToken&& token,
> typename enable_if<is_executor<Executor>::value>::type* = 0);
>
>
>
>
>
>template <typename ExecutionContext, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
> ExecutionContext& ctx, CompletionToken&& token,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type* = 0);
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 106 "/usr/include/boost/asio/post.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/post.hpp" 1 3 4
># 21 "/usr/include/boost/asio/impl/post.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/work_dispatcher.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/work_dispatcher.hpp" 3 4
># 1 "/usr/include/boost/asio/executor_work_guard.hpp" 1 3 4
># 23 "/usr/include/boost/asio/executor_work_guard.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/executor_work_guard.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>template <typename Executor>
>class executor_work_guard
>{
>public:
>
> typedef Executor executor_type;
>
>
>
>
>
> explicit executor_work_guard(const executor_type& e) noexcept
> : executor_(e),
> owns_(true)
> {
> executor_.on_work_started();
> }
>
>
> executor_work_guard(const executor_work_guard& other) noexcept
> : executor_(other.executor_),
> owns_(other.owns_)
> {
> if (owns_)
> executor_.on_work_started();
> }
>
>
>
> executor_work_guard(executor_work_guard&& other)
> : executor_(static_cast<Executor&&>(other.executor_)),
> owns_(other.owns_)
> {
> other.owns_ = false;
> }
>
>
>
>
>
>
>
> ~executor_work_guard()
> {
> if (owns_)
> executor_.on_work_finished();
> }
>
>
> executor_type get_executor() const noexcept
> {
> return executor_;
> }
>
>
> bool owns_work() const noexcept
> {
> return owns_;
> }
>
>
>
>
>
>
> void reset() noexcept
> {
> if (owns_)
> {
> executor_.on_work_finished();
> owns_ = false;
> }
> }
>
>private:
>
> executor_work_guard& operator=(const executor_work_guard&);
>
> executor_type executor_;
> bool owns_;
>};
>
>
>template <typename Executor>
>inline executor_work_guard<Executor> make_work_guard(const Executor& ex,
> typename enable_if<is_executor<Executor>::value>::type* = 0)
>{
> return executor_work_guard<Executor>(ex);
>}
>
>
>template <typename ExecutionContext>
>inline executor_work_guard<typename ExecutionContext::executor_type>
>make_work_guard(ExecutionContext& ctx,
> typename enable_if<
> is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
>{
> return executor_work_guard<typename ExecutionContext::executor_type>(
> ctx.get_executor());
>}
>
>
>template <typename T>
>inline executor_work_guard<typename associated_executor<T>::type>
>make_work_guard(const T& t,
> typename enable_if<!is_executor<T>::value &&
> !is_convertible<T&, execution_context&>::value>::type* = 0)
>{
> return executor_work_guard<typename associated_executor<T>::type>(
> associated_executor<T>::get(t));
>}
>
>
>template <typename T, typename Executor>
>inline executor_work_guard<typename associated_executor<T, Executor>::type>
>make_work_guard(const T& t, const Executor& ex,
> typename enable_if<is_executor<Executor>::value>::type* = 0)
>{
> return executor_work_guard<typename associated_executor<T, Executor>::type>(
> associated_executor<T, Executor>::get(t, ex));
>}
>
>
>template <typename T, typename ExecutionContext>
>inline executor_work_guard<typename associated_executor<T,
> typename ExecutionContext::executor_type>::type>
>make_work_guard(const T& t, ExecutionContext& ctx,
> typename enable_if<!is_executor<T>::value &&
> !is_convertible<T&, execution_context&>::value>::type* = 0)
>{
> return executor_work_guard<typename associated_executor<T,
> typename ExecutionContext::executor_type>::type>(
> associated_executor<T, typename ExecutionContext::executor_type>::get(
> t, ctx.get_executor()));
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 170 "/usr/include/boost/asio/executor_work_guard.hpp" 2 3 4
># 22 "/usr/include/boost/asio/detail/work_dispatcher.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/work_dispatcher.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class work_dispatcher
>{
>public:
> work_dispatcher(Handler& handler)
> : work_((get_associated_executor)(handler)),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
>
> work_dispatcher(const work_dispatcher& other)
> : work_(other.work_),
> handler_(other.handler_)
> {
> }
>
> work_dispatcher(work_dispatcher&& other)
> : work_(static_cast<executor_work_guard< typename associated_executor<Handler>::type>&&>
> (other.work_)),
> handler_(static_cast<Handler&&>(other.handler_))
> {
> }
>
>
> void operator()()
> {
> typename associated_allocator<Handler>::type alloc(
> (get_associated_allocator)(handler_));
> work_.get_executor().dispatch(
> static_cast<Handler&&>(handler_), alloc);
> work_.reset();
> }
>
>private:
> executor_work_guard<typename associated_executor<Handler>::type> work_;
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 73 "/usr/include/boost/asio/detail/work_dispatcher.hpp" 2 3 4
># 22 "/usr/include/boost/asio/impl/post.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/impl/post.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
> CompletionToken&& token)
>{
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;
>
> async_completion<CompletionToken, void()> init(token);
>
> typename associated_executor<handler>::type ex(
> (get_associated_executor)(init.completion_handler));
>
> typename associated_allocator<handler>::type alloc(
> (get_associated_allocator)(init.completion_handler));
>
> ex.post(static_cast<handler&&>(init.completion_handler), alloc);
>
> return init.result.get();
>}
>
>template <typename Executor, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
> const Executor& ex, CompletionToken&& token,
> typename enable_if<is_executor<Executor>::value>::type*)
>{
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;
>
> async_completion<CompletionToken, void()> init(token);
>
> typename associated_allocator<handler>::type alloc(
> (get_associated_allocator)(init.completion_handler));
>
> ex.post(detail::work_dispatcher<handler>(init.completion_handler), alloc);
>
> return init.result.get();
>}
>
>template <typename ExecutionContext, typename CompletionToken>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type post(
> ExecutionContext& ctx, CompletionToken&& token,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type*)
>{
> return (post)(ctx.get_executor(),
> static_cast<CompletionToken&&>(token));
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 78 "/usr/include/boost/asio/impl/post.hpp" 2 3 4
># 108 "/usr/include/boost/asio/post.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
># 1 "/usr/include/boost/asio/socket_base.hpp" 1 3 4
># 19 "/usr/include/boost/asio/socket_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/io_control.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/io_control.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/io_control.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace io_control {
>
>
>class bytes_readable
>{
>public:
>
> bytes_readable()
> : value_(0)
> {
> }
>
>
> bytes_readable(std::size_t value)
> : value_(static_cast<detail::ioctl_arg_type>(value))
> {
> }
>
>
> int name() const
> {
> return static_cast<int>(0x541B);
> }
>
>
> void set(std::size_t value)
> {
> value_ = static_cast<detail::ioctl_arg_type>(value);
> }
>
>
> std::size_t get() const
> {
> return static_cast<std::size_t>(value_);
> }
>
>
> detail::ioctl_arg_type* data()
> {
> return &value_;
> }
>
>
> const detail::ioctl_arg_type* data() const
> {
> return &value_;
> }
>
>private:
> detail::ioctl_arg_type value_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 85 "/usr/include/boost/asio/detail/io_control.hpp" 2 3 4
># 20 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/socket_option.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/socket_option.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/socket_option.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace socket_option {
>
>
>template <int Level, int Name>
>class boolean
>{
>public:
>
> boolean()
> : value_(0)
> {
> }
>
>
> explicit boolean(bool v)
> : value_(v ? 1 : 0)
> {
> }
>
>
> boolean& operator=(bool v)
> {
> value_ = v ? 1 : 0;
> return *this;
> }
>
>
> bool value() const
> {
> return !!value_;
> }
>
>
> operator bool() const
> {
> return !!value_;
> }
>
>
> bool operator!() const
> {
> return !value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol&) const
> {
> return Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol&) const
> {
> return Name;
> }
>
>
> template <typename Protocol>
> int* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const int* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
>
>
>
> switch (s)
> {
> case sizeof(char):
> value_ = *reinterpret_cast<char*>(&value_) ? 1 : 0;
> break;
> case sizeof(value_):
> break;
> default:
> {
> std::length_error ex("boolean socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> }
> }
>
>private:
> int value_;
>};
>
>
>template <int Level, int Name>
>class integer
>{
>public:
>
> integer()
> : value_(0)
> {
> }
>
>
> explicit integer(int v)
> : value_(v)
> {
> }
>
>
> integer& operator=(int v)
> {
> value_ = v;
> return *this;
> }
>
>
> int value() const
> {
> return value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol&) const
> {
> return Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol&) const
> {
> return Name;
> }
>
>
> template <typename Protocol>
> int* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const int* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
> if (s != sizeof(value_))
> {
> std::length_error ex("integer socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>private:
> int value_;
>};
>
>
>template <int Level, int Name>
>class linger
>{
>public:
>
> linger()
> {
> value_.l_onoff = 0;
> value_.l_linger = 0;
> }
>
>
> linger(bool e, int t)
> {
> enabled(e);
> timeout (t);
> }
>
>
> void enabled(bool value)
> {
> value_.l_onoff = value ? 1 : 0;
> }
>
>
> bool enabled() const
> {
> return value_.l_onoff != 0;
> }
>
>
> void timeout (int value)
> {
>
>
>
> value_.l_linger = value;
>
> }
>
>
> int timeout () const
> {
> return static_cast<int>(value_.l_linger);
> }
>
>
> template <typename Protocol>
> int level(const Protocol&) const
> {
> return Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol&) const
> {
> return Name;
> }
>
>
> template <typename Protocol>
> detail::linger_type* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const detail::linger_type* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
> if (s != sizeof(value_))
> {
> std::length_error ex("linger socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>private:
> detail::linger_type value_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 317 "/usr/include/boost/asio/detail/socket_option.hpp" 2 3 4
># 21 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>
>class socket_base
>{
>public:
>
> enum shutdown_type
> {
># 47 "/usr/include/boost/asio/socket_base.hpp" 3 4
> shutdown_receive = SHUT_RD,
> shutdown_send = SHUT_WR,
> shutdown_both = SHUT_RDWR
>
> };
>
>
> typedef int message_flags;
># 69 "/usr/include/boost/asio/socket_base.hpp" 3 4
> static const int message_peek = MSG_PEEK
> ;
> static const int message_out_of_band = MSG_OOB
> ;
> static const int message_do_not_route = MSG_DONTROUTE
> ;
> static const int message_end_of_record = MSG_EOR
> ;
>
>
>
>
>
>
> enum wait_type
> {
>
> wait_read,
>
>
> wait_write,
>
>
> wait_error
> };
># 124 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 6>
> broadcast;
># 158 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 1> debug;
># 191 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 5>
> do_not_route;
># 225 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 9> keep_alive;
># 258 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 7>
> send_buffer_size;
># 292 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 19>
> send_low_watermark;
># 326 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 8>
> receive_buffer_size;
># 360 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::integer<
> 1, 18>
> receive_low_watermark;
># 395 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 2>
> reuse_address;
># 431 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::linger<
> 1, 13>
> linger;
># 465 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> 1, 10>
> out_of_band_inline;
># 501 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> boost::asio::detail::custom_socket_option_level,
> boost::asio::detail::enable_connection_aborted_option>
> enable_connection_aborted;
># 527 "/usr/include/boost/asio/socket_base.hpp" 3 4
> typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
>
>
>
>
>
>
> static const int max_listen_connections = 128
> ;
># 544 "/usr/include/boost/asio/socket_base.hpp" 3 4
> static const int max_connections = 128
> ;
>
>
>
>protected:
>
> ~socket_base()
> {
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 560 "/usr/include/boost/asio/socket_base.hpp" 2 3 4
># 27 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
># 40 "/usr/include/boost/asio/basic_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 3 4
># 1 "/usr/include/boost/asio/buffer.hpp" 1 3 4
># 20 "/usr/include/boost/asio/buffer.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 21 "/usr/include/boost/asio/buffer.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/array_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/array_fwd.hpp" 3 4
>namespace boost {
>
>template<class T, std::size_t N>
>class array;
>
>}
># 26 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/is_buffer_sequence.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/is_buffer_sequence.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/is_buffer_sequence.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class mutable_buffer;
>class const_buffer;
>
>namespace detail {
>
>struct buffer_sequence_memfns_base
>{
> void begin();
> void end();
> void size();
> void max_size();
> void capacity();
> void data();
> void prepare();
> void commit();
> void consume();
>};
>
>template <typename T>
>struct buffer_sequence_memfns_derived
> : T, buffer_sequence_memfns_base
>{
>};
>
>template <typename T, T>
>struct buffer_sequence_memfns_check
>{
>};
>
>template <typename>
>char (&begin_memfn_helper(...))[2];
>
>template <typename T>
>char begin_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::begin>*);
>
>template <typename>
>char (&end_memfn_helper(...))[2];
>
>template <typename T>
>char end_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::end>*);
>
>template <typename>
>char (&size_memfn_helper(...))[2];
>
>template <typename T>
>char size_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::size>*);
>
>template <typename>
>char (&max_size_memfn_helper(...))[2];
>
>template <typename T>
>char max_size_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::max_size>*);
>
>template <typename>
>char (&capacity_memfn_helper(...))[2];
>
>template <typename T>
>char capacity_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::capacity>*);
>
>template <typename>
>char (&data_memfn_helper(...))[2];
>
>template <typename T>
>char data_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::data>*);
>
>template <typename>
>char (&prepare_memfn_helper(...))[2];
>
>template <typename T>
>char prepare_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::data>*);
>
>template <typename>
>char (&commit_memfn_helper(...))[2];
>
>template <typename T>
>char commit_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::commit>*);
>
>template <typename>
>char (&consume_memfn_helper(...))[2];
>
>template <typename T>
>char consume_memfn_helper(
> buffer_sequence_memfns_check<
> void (buffer_sequence_memfns_base::*)(),
> &buffer_sequence_memfns_derived<T>::consume>*);
>
>template <typename, typename>
>char (&buffer_element_type_helper(...))[2];
># 149 "/usr/include/boost/asio/detail/is_buffer_sequence.hpp" 3 4
>template <typename T, typename Buffer>
>char buffer_element_type_helper(
> typename T::const_iterator*,
> typename enable_if<is_convertible<
> typename T::value_type, Buffer>::value>::type*);
>
>
>
>template <typename>
>char (&const_buffers_type_typedef_helper(...))[2];
>
>template <typename T>
>char const_buffers_type_typedef_helper(
> typename T::const_buffers_type*);
>
>template <typename>
>char (&mutable_buffers_type_typedef_helper(...))[2];
>
>template <typename T>
>char mutable_buffers_type_typedef_helper(
> typename T::mutable_buffers_type*);
>
>template <typename T, typename Buffer>
>struct is_buffer_sequence_class
> : integral_constant<bool,
> sizeof(begin_memfn_helper<T>(0)) != 1 &&
> sizeof(end_memfn_helper<T>(0)) != 1 &&
> sizeof(buffer_element_type_helper<T, Buffer>(0, 0)) == 1>
>{
>};
>
>template <typename T, typename Buffer>
>struct is_buffer_sequence
> : conditional<is_class<T>::value,
> is_buffer_sequence_class<T, Buffer>,
> false_type>::type
>{
>};
>
>template <>
>struct is_buffer_sequence<mutable_buffer, mutable_buffer>
> : true_type
>{
>};
>
>template <>
>struct is_buffer_sequence<mutable_buffer, const_buffer>
> : true_type
>{
>};
>
>template <>
>struct is_buffer_sequence<const_buffer, const_buffer>
> : true_type
>{
>};
>
>template <>
>struct is_buffer_sequence<const_buffer, mutable_buffer>
> : false_type
>{
>};
>
>template <typename T>
>struct is_dynamic_buffer_class
> : integral_constant<bool,
> sizeof(size_memfn_helper<T>(0)) != 1 &&
> sizeof(max_size_memfn_helper<T>(0)) != 1 &&
> sizeof(capacity_memfn_helper<T>(0)) != 1 &&
> sizeof(data_memfn_helper<T>(0)) != 1 &&
> sizeof(consume_memfn_helper<T>(0)) != 1 &&
> sizeof(prepare_memfn_helper<T>(0)) != 1 &&
> sizeof(commit_memfn_helper<T>(0)) != 1 &&
> sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 &&
> sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1>
>{
>};
>
>template <typename T>
>struct is_dynamic_buffer
> : conditional<is_class<T>::value,
> is_dynamic_buffer_class<T>,
> false_type>::type
>{
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 240 "/usr/include/boost/asio/detail/is_buffer_sequence.hpp" 2 3 4
># 27 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/string_view.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/string_view.hpp" 3 4
># 1 "/usr/include/c++/8/experimental/string_view" 1 3 4
># 36 "/usr/include/c++/8/experimental/string_view" 3 4
> 
># 37 "/usr/include/c++/8/experimental/string_view" 3
>
>
>
>
>
># 1 "/usr/include/c++/8/experimental/bits/lfts_config.h" 1 3
># 43 "/usr/include/c++/8/experimental/string_view" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>namespace experimental
>{
>inline namespace fundamentals_v1
>{
># 73 "/usr/include/c++/8/experimental/string_view" 3
> template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
> class basic_string_view
> {
> public:
>
>
> using traits_type = _Traits;
> using value_type = _CharT;
> using pointer = const _CharT*;
> using const_pointer = const _CharT*;
> using reference = const _CharT&;
> using const_reference = const _CharT&;
> using const_iterator = const _CharT*;
> 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;
>
> template<typename _Allocator>
> basic_string_view(const basic_string<_CharT, _Traits,
> _Allocator>& __str) noexcept
> : _M_len{__str.length()}, _M_str{__str.data()}
> { }
>
> constexpr basic_string_view(const _CharT* __str)
> : _M_len{__str == nullptr ? 0 : traits_type::length(__str)},
> _M_str{__str}
> { }
>
> constexpr basic_string_view(const _CharT* __str, size_type __len)
> : _M_len{__len},
> _M_str{__str}
> { }
>
> basic_string_view&
> operator=(const basic_string_view&) noexcept = default;
>
>
>
> constexpr const_iterator
> begin() const noexcept
> { return this->_M_str; }
>
> constexpr const_iterator
> end() const noexcept
> { return this->_M_str + this->_M_len; }
>
> constexpr const_iterator
> cbegin() const noexcept
> { return this->_M_str; }
>
> constexpr const_iterator
> cend() const noexcept
> { return this->_M_str + this->_M_len; }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
>
> constexpr size_type
> size() const noexcept
> { return this->_M_len; }
>
> constexpr size_type
> length() const noexcept
> { return _M_len; }
>
> constexpr size_type
> max_size() const noexcept
> {
> return (npos - sizeof(size_type) - sizeof(void*))
> / sizeof(value_type) / 4;
> }
>
> constexpr bool
> empty() const noexcept
> { return this->_M_len == 0; }
>
>
>
> constexpr const _CharT&
> operator[](size_type __pos) const
> {
>
>
> return *(this->_M_str + __pos);
> }
>
> constexpr const _CharT&
> at(size_type __pos) const
> {
> return __pos < this->_M_len
> ? *(this->_M_str + __pos)
> : (__throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)")
>
> ,
> __pos, this->size()),
> *this->_M_str);
> }
>
> constexpr const _CharT&
> front() const
> {
>
>
> return *this->_M_str;
> }
>
> constexpr const _CharT&
> back() const
> {
>
>
> return *(this->_M_str + this->_M_len - 1);
> }
>
> constexpr const _CharT*
> data() const noexcept
> { return this->_M_str; }
>
>
>
> constexpr void
> remove_prefix(size_type __n)
> {
> ;
> this->_M_str += __n;
> this->_M_len -= __n;
> }
>
> constexpr void
> remove_suffix(size_type __n)
> { this->_M_len -= __n; }
>
> constexpr void
> swap(basic_string_view& __sv) noexcept
> {
> auto __tmp = *this;
> *this = __sv;
> __sv = __tmp;
> }
>
>
>
>
> template<typename _Allocator>
> explicit operator basic_string<_CharT, _Traits, _Allocator>() const
> {
> return { this->_M_str, this->_M_len };
> }
>
> template<typename _Allocator = std::allocator<_CharT>>
> basic_string<_CharT, _Traits, _Allocator>
> to_string(const _Allocator& __alloc = _Allocator()) const
> {
> return { this->_M_str, this->_M_len, __alloc };
> }
>
> size_type
> copy(_CharT* __str, size_type __n, size_type __pos = 0) const
> {
> ;
> if (__pos > this->_M_len)
> __throw_out_of_range_fmt(("basic_string_view::copy: __pos " "(which is %zu) > this->size() " "(which is %zu)")
>
> ,
> __pos, this->size());
> size_type __rlen{std::min(__n, size_type{this->_M_len - __pos})};
> for (auto __begin = this->_M_str + __pos,
> __end = __begin + __rlen; __begin != __end;)
> *__str++ = *__begin++;
> return __rlen;
> }
>
>
>
>
> constexpr basic_string_view
> substr(size_type __pos, size_type __n=npos) const
> {
> return __pos <= this->_M_len
> ? basic_string_view{this->_M_str + __pos,
> std::min(__n, size_type{this->_M_len - __pos})}
> : (__throw_out_of_range_fmt(("basic_string_view::substr: __pos " "(which is %zu) > this->size() " "(which is %zu)")
>
> ,
> __pos, this->size()), basic_string_view{});
> }
>
> constexpr int
> compare(basic_string_view __str) const noexcept
> {
> int __ret = traits_type::compare(this->_M_str, __str._M_str,
> std::min(this->_M_len, __str._M_len));
> if (__ret == 0)
> __ret = _S_compare(this->_M_len, __str._M_len);
> return __ret;
> }
>
> constexpr int
> compare(size_type __pos1, size_type __n1, basic_string_view __str) const
> { return this->substr(__pos1, __n1).compare(__str); }
>
> constexpr int
> compare(size_type __pos1, size_type __n1,
> basic_string_view __str, size_type __pos2, size_type __n2) const
> { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); }
>
> constexpr int
> compare(const _CharT* __str) const noexcept
> { return this->compare(basic_string_view{__str}); }
>
> constexpr int
> compare(size_type __pos1, size_type __n1, const _CharT* __str) const
> { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
>
> constexpr int
> compare(size_type __pos1, size_type __n1,
> const _CharT* __str, size_type __n2) const
> {
> return this->substr(__pos1, __n1)
> .compare(basic_string_view(__str, __n2));
> }
>
> constexpr size_type
> find(basic_string_view __str, size_type __pos = 0) const noexcept
> { return this->find(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find(_CharT __c, size_type __pos=0) const noexcept;
>
> constexpr size_type
> find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
>
> constexpr size_type
> find(const _CharT* __str, size_type __pos=0) const noexcept
> { return this->find(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> rfind(basic_string_view __str, size_type __pos = npos) const noexcept
> { return this->rfind(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> rfind(_CharT __c, size_type __pos = npos) const noexcept;
>
> constexpr size_type
> rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
>
> constexpr size_type
> rfind(const _CharT* __str, size_type __pos = npos) const noexcept
> { return this->rfind(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
> { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_first_of(_CharT __c, size_type __pos = 0) const noexcept
> { return this->find(__c, __pos); }
>
> constexpr size_type
> find_first_of(const _CharT* __str, size_type __pos, size_type __n) const;
>
> constexpr size_type
> find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
> { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> find_last_of(basic_string_view __str,
> size_type __pos = npos) const noexcept
> { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_last_of(_CharT __c, size_type __pos=npos) const noexcept
> { return this->rfind(__c, __pos); }
>
> constexpr size_type
> find_last_of(const _CharT* __str, size_type __pos, size_type __n) const;
>
> constexpr size_type
> find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
> { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
>
> constexpr size_type
> find_first_not_of(basic_string_view __str,
> size_type __pos = 0) const noexcept
> { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
>
> constexpr size_type
> find_first_not_of(const _CharT* __str,
> size_type __pos, size_type __n) const;
>
> constexpr size_type
> find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
> {
> return this->find_first_not_of(__str, __pos,
> traits_type::length(__str));
> }
>
> constexpr size_type
> find_last_not_of(basic_string_view __str,
> size_type __pos = npos) const noexcept
> { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
>
> constexpr size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
>
> constexpr size_type
> find_last_not_of(const _CharT* __str,
> size_type __pos, size_type __n) const;
>
> 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
> {
> return difference_type(__n1 - __n2) > std::numeric_limits<int>::max()
> ? std::numeric_limits<int>::max()
> : difference_type(__n1 - __n2) < std::numeric_limits<int>::min()
> ? std::numeric_limits<int>::min()
> : static_cast<int>(difference_type(__n1 - __n2));
> }
>
> size_t _M_len;
> const _CharT* _M_str;
> };
>
>
>
> namespace __detail
> {
>
>
>
> template<typename _Tp>
> using __idt = common_type_t<_Tp>;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator==(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.size() == __y.size() && __x.compare(__y) == 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator==(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.size() == __y.size() && __x.compare(__y) == 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator==(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.size() == __y.size() && __x.compare(__y) == 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator!=(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return !(__x == __y); }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator!=(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return !(__x == __y); }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator!=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return !(__x == __y); }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator< (basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) < 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator< (basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) < 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator< (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) < 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator> (basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) > 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator> (basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) > 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) > 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator<=(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) <= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator<=(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) <= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator<=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) <= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator>=(basic_string_view<_CharT, _Traits> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) >= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator>=(basic_string_view<_CharT, _Traits> __x,
> __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
> { return __x.compare(__y) >= 0; }
>
> template<typename _CharT, typename _Traits>
> constexpr bool
> operator>=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
> basic_string_view<_CharT, _Traits> __y) noexcept
> { return __x.compare(__y) >= 0; }
>
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os,
> basic_string_view<_CharT,_Traits> __str)
> { return __ostream_insert(__os, __str.data(), __str.size()); }
>
>
>
>
> using string_view = basic_string_view<char>;
>
> using wstring_view = basic_string_view<wchar_t>;
>
>
> using u16string_view = basic_string_view<char16_t>;
> using u32string_view = basic_string_view<char32_t>;
>
>}
>}
>
>
>
> template<typename _Tp>
> struct hash;
>
> template<>
> struct hash<experimental::string_view>
> : public __hash_base<size_t, experimental::string_view>
> {
> size_t
> operator()(const experimental::string_view& __str) const noexcept
> { return std::_Hash_impl::hash(__str.data(), __str.length()); }
> };
>
> template<>
> struct __is_fast_hash<hash<experimental::string_view>> : std::false_type
> { };
>
>
> template<>
> struct hash<experimental::wstring_view>
> : public __hash_base<size_t, wstring>
> {
> size_t
> operator()(const experimental::wstring_view& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(wchar_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<experimental::wstring_view>> : std::false_type
> { };
>
>
>
> template<>
> struct hash<experimental::u16string_view>
> : public __hash_base<size_t, experimental::u16string_view>
> {
> size_t
> operator()(const experimental::u16string_view& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char16_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<experimental::u16string_view>> : std::false_type
> { };
>
> template<>
> struct hash<experimental::u32string_view>
> : public __hash_base<size_t, experimental::u32string_view>
> {
> size_t
> operator()(const experimental::u32string_view& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char32_t)); }
> };
>
> template<>
> struct __is_fast_hash<hash<experimental::u32string_view>> : std::false_type
> { };
>
>
>namespace experimental
>{
>
> inline namespace literals
> {
> inline namespace string_view_literals
> {
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wliteral-suffix"
> inline constexpr basic_string_view<char>
> operator""sv(const char* __str, size_t __len) noexcept
> { return basic_string_view<char>{__str, __len}; }
>
>
> inline constexpr basic_string_view<wchar_t>
> operator""sv(const wchar_t* __str, size_t __len) noexcept
> { return basic_string_view<wchar_t>{__str, __len}; }
>
>
>
> inline constexpr basic_string_view<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
> }
> }
>}
>
>
>}
>
># 1 "/usr/include/c++/8/experimental/bits/string_view.tcc" 1 3
># 37 "/usr/include/c++/8/experimental/bits/string_view.tcc" 3
> 
># 38 "/usr/include/c++/8/experimental/bits/string_view.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>namespace experimental
>{
>inline namespace fundamentals_v1
>{
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
> {
> ;
>
> if (__n == 0)
> return __pos <= this->_M_len ? __pos : npos;
>
> if (__n <= this->_M_len)
> {
> for (; __pos <= this->_M_len - __n; ++__pos)
> if (traits_type::eq(this->_M_str[__pos], __str[0])
> && traits_type::compare(this->_M_str + __pos + 1,
> __str + 1, __n - 1) == 0)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find(_CharT __c, size_type __pos) const noexcept
> {
> size_type __ret = npos;
> if (__pos < this->_M_len)
> {
> const size_type __n = this->_M_len - __pos;
> const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
> if (__p)
> __ret = __p - this->_M_str;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
> {
> ;
>
> if (__n <= this->_M_len)
> {
> __pos = std::min(size_type(this->_M_len - __n), __pos);
> do
> {
> if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
> return __pos;
> }
> while (__pos-- > 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> rfind(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->_M_len;
> if (__size > 0)
> {
> if (--__size > __pos)
> __size = __pos;
> for (++__size; __size-- > 0; )
> if (traits_type::eq(this->_M_str[__size], __c))
> return __size;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits>
> constexpr typename basic_string_view<_CharT, _Traits>::size_type
> basic_string_view<_CharT, _Traits>::
> find_first_of(const _CharT* __str, size_type __pos, size_type __n) const
> {
> ;
> 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
> {
> ;
> 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
> {
> ;
> 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
> {
> ;
> 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;
> }
>}
>}
>
>
>}
># 677 "/usr/include/c++/8/experimental/string_view" 2 3
># 24 "/usr/include/boost/asio/detail/string_view.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>
>
>using std::experimental::basic_string_view;
>using std::experimental::string_view;
>
>
>
>
>
>}
>}
># 28 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 64 "/usr/include/boost/asio/buffer.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 65 "/usr/include/boost/asio/buffer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>class mutable_buffer;
>class const_buffer;
># 91 "/usr/include/boost/asio/buffer.hpp" 3 4
>class mutable_buffer
>{
>public:
>
> mutable_buffer() noexcept
> : data_(0),
> size_(0)
> {
> }
>
>
> mutable_buffer(void* data, std::size_t size) noexcept
> : data_(data),
> size_(size)
> {
> }
># 124 "/usr/include/boost/asio/buffer.hpp" 3 4
> void* data() const noexcept
> {
>
>
>
>
> return data_;
> }
>
>
> std::size_t size() const noexcept
> {
> return size_;
> }
>
>
> mutable_buffer& operator+=(std::size_t n) noexcept
> {
> std::size_t offset = n < size_ ? n : size_;
> data_ = static_cast<char*>(data_) + offset;
> size_ -= offset;
> return *this;
> }
>
>private:
> void* data_;
> std::size_t size_;
>
>
>
>
>};
>
>
>
>
>
>class mutable_buffers_1
> : public mutable_buffer
>{
>public:
>
> typedef mutable_buffer value_type;
>
>
> typedef const mutable_buffer* const_iterator;
>
>
> mutable_buffers_1(void* data, std::size_t size) noexcept
> : mutable_buffer(data, size)
> {
> }
># 186 "/usr/include/boost/asio/buffer.hpp" 3 4
> explicit mutable_buffers_1(const mutable_buffer& b) noexcept
> : mutable_buffer(b)
> {
> }
>
>
> const_iterator begin() const noexcept
> {
> return this;
> }
>
>
> const_iterator end() const noexcept
> {
> return begin() + 1;
> }
>};
># 225 "/usr/include/boost/asio/buffer.hpp" 3 4
>class const_buffer
>{
>public:
>
> const_buffer() noexcept
> : data_(0),
> size_(0)
> {
> }
>
>
> const_buffer(const void* data, std::size_t size) noexcept
> : data_(data),
> size_(size)
> {
> }
>
>
> const_buffer(const mutable_buffer& b) noexcept
> : data_(b.data()),
> size_(b.size())
>
>
>
> {
> }
># 268 "/usr/include/boost/asio/buffer.hpp" 3 4
> const void* data() const noexcept
> {
>
>
>
>
> return data_;
> }
>
>
> std::size_t size() const noexcept
> {
> return size_;
> }
>
>
> const_buffer& operator+=(std::size_t n) noexcept
> {
> std::size_t offset = n < size_ ? n : size_;
> data_ = static_cast<const char*>(data_) + offset;
> size_ -= offset;
> return *this;
> }
>
>private:
> const void* data_;
> std::size_t size_;
>
>
>
>
>};
>
>
>
>
>
>class const_buffers_1
> : public const_buffer
>{
>public:
>
> typedef const_buffer value_type;
>
>
> typedef const const_buffer* const_iterator;
>
>
> const_buffers_1(const void* data, std::size_t size) noexcept
> : const_buffer(data, size)
> {
> }
># 330 "/usr/include/boost/asio/buffer.hpp" 3 4
> explicit const_buffers_1(const const_buffer& b) noexcept
> : const_buffer(b)
> {
> }
>
>
> const_iterator begin() const noexcept
> {
> return this;
> }
>
>
> const_iterator end() const noexcept
> {
> return begin() + 1;
> }
>};
>
>
>
>
>
>template <typename T>
>struct is_mutable_buffer_sequence
>
>
>
> : boost::asio::detail::is_buffer_sequence<T, mutable_buffer>
>
>{
>};
>
>
>
>template <typename T>
>struct is_const_buffer_sequence
>
>
>
> : boost::asio::detail::is_buffer_sequence<T, const_buffer>
>
>{
>};
>
>
>template <typename T>
>struct is_dynamic_buffer
>
>
>
> : boost::asio::detail::is_dynamic_buffer<T>
>
>{
>};
>
>
>
>
>class null_buffers
>{
>public:
>
> typedef mutable_buffer value_type;
>
>
> typedef const mutable_buffer* const_iterator;
>
>
> const_iterator begin() const noexcept
> {
> return &buf_;
> }
>
>
> const_iterator end() const noexcept
> {
> return &buf_;
> }
>
>private:
> mutable_buffer buf_;
>};
># 421 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline const mutable_buffer* buffer_sequence_begin(const mutable_buffer& b)
>{
> return &b;
>}
>
>
>inline const const_buffer* buffer_sequence_begin(const const_buffer& b)
>{
> return &b;
>}
>
>
>
>
>template <typename C>
>inline auto buffer_sequence_begin(C& c) -> decltype(c.begin())
>{
> return c.begin();
>}
>
>
>template <typename C>
>inline auto buffer_sequence_begin(const C& c) -> decltype(c.begin())
>{
> return c.begin();
>}
># 474 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline const mutable_buffer* buffer_sequence_end(const mutable_buffer& b)
>{
> return &b + 1;
>}
>
>
>inline const const_buffer* buffer_sequence_end(const const_buffer& b)
>{
> return &b + 1;
>}
>
>
>
>
>template <typename C>
>inline auto buffer_sequence_end(C& c) -> decltype(c.end())
>{
> return c.end();
>}
>
>
>template <typename C>
>inline auto buffer_sequence_end(const C& c) -> decltype(c.end())
>{
> return c.end();
>}
># 519 "/usr/include/boost/asio/buffer.hpp" 3 4
>namespace detail {
>
>
>struct one_buffer {};
>struct multiple_buffers {};
>
>
>template <typename BufferSequence>
>struct buffer_sequence_cardinality :
> conditional<
> is_same<BufferSequence, mutable_buffer>::value
>
> || is_same<BufferSequence, mutable_buffers_1>::value
> || is_same<BufferSequence, const_buffers_1>::value
>
> || is_same<BufferSequence, const_buffer>::value,
> one_buffer, multiple_buffers>::type {};
>
>template <typename Iterator>
>inline std::size_t buffer_size(one_buffer,
> Iterator begin, Iterator) noexcept
>{
> return const_buffer(*begin).size();
>}
>
>template <typename Iterator>
>inline std::size_t buffer_size(multiple_buffers,
> Iterator begin, Iterator end) noexcept
>{
> std::size_t total_buffer_size = 0;
>
> Iterator iter = begin;
> for (; iter != end; ++iter)
> {
> const_buffer b(*iter);
> total_buffer_size += b.size();
> }
>
> return total_buffer_size;
>}
>
>}
># 580 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename BufferSequence>
>inline std::size_t buffer_size(const BufferSequence& b) noexcept
>{
> return detail::buffer_size(
> detail::buffer_sequence_cardinality<BufferSequence>(),
> boost::asio::buffer_sequence_begin(b),
> boost::asio::buffer_sequence_end(b));
>}
># 615 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PointerToPodType>
>inline PointerToPodType buffer_cast(const mutable_buffer& b) noexcept
>{
> return static_cast<PointerToPodType>(b.data());
>}
>
>
>template <typename PointerToPodType>
>inline PointerToPodType buffer_cast(const const_buffer& b) noexcept
>{
> return static_cast<PointerToPodType>(b.data());
>}
># 636 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline mutable_buffer operator+(const mutable_buffer& b,
> std::size_t n) noexcept
>{
> std::size_t offset = n < b.size() ? n : b.size();
> char* new_data = static_cast<char*>(b.data()) + offset;
> std::size_t new_size = b.size() - offset;
> return mutable_buffer(new_data, new_size
>
>
>
> );
>}
>
>
>
>
>
>inline mutable_buffer operator+(std::size_t n,
> const mutable_buffer& b) noexcept
>{
> return b + n;
>}
>
>
>
>
>
>inline const_buffer operator+(const const_buffer& b,
> std::size_t n) noexcept
>{
> std::size_t offset = n < b.size() ? n : b.size();
> const char* new_data = static_cast<const char*>(b.data()) + offset;
> std::size_t new_size = b.size() - offset;
> return const_buffer(new_data, new_size
>
>
>
> );
>}
>
>
>
>
>
>inline const_buffer operator+(std::size_t n,
> const const_buffer& b) noexcept
>{
> return b + n;
>}
># 895 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline mutable_buffers_1 buffer(
> const mutable_buffer& b) noexcept
>{
> return mutable_buffers_1(b);
>}
># 908 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline mutable_buffers_1 buffer(const mutable_buffer& b,
> std::size_t max_size_in_bytes) noexcept
>{
> return mutable_buffers_1(
> mutable_buffer(b.data(),
> b.size() < max_size_in_bytes
> ? b.size() : max_size_in_bytes
>
>
>
> ));
>}
>
>
>
>
>
>inline const_buffers_1 buffer(
> const const_buffer& b) noexcept
>{
> return const_buffers_1(b);
>}
># 938 "/usr/include/boost/asio/buffer.hpp" 3 4
>inline const_buffers_1 buffer(const const_buffer& b,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(b.data(),
> b.size() < max_size_in_bytes
> ? b.size() : max_size_in_bytes
>
>
>
> );
>}
>
>
>
>
>
>inline mutable_buffers_1 buffer(void* data,
> std::size_t size_in_bytes) noexcept
>{
> return mutable_buffers_1(data, size_in_bytes);
>}
>
>
>
>
>
>inline const_buffers_1 buffer(const void* data,
> std::size_t size_in_bytes) noexcept
>{
> return const_buffers_1(data, size_in_bytes);
>}
># 977 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(PodType (&data)[N]) noexcept
>{
> return mutable_buffers_1(data, N * sizeof(PodType));
>}
># 990 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(PodType (&data)[N],
> std::size_t max_size_in_bytes) noexcept
>{
> return mutable_buffers_1(data,
> N * sizeof(PodType) < max_size_in_bytes
> ? N * sizeof(PodType) : max_size_in_bytes);
>}
># 1006 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(
> const PodType (&data)[N]) noexcept
>{
> return const_buffers_1(data, N * sizeof(PodType));
>}
># 1020 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const PodType (&data)[N],
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data,
> N * sizeof(PodType) < max_size_in_bytes
> ? N * sizeof(PodType) : max_size_in_bytes);
>}
># 1106 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(
> boost::array<PodType, N>& data) noexcept
>{
> return mutable_buffers_1(
> data.c_array(), data.size() * sizeof(PodType));
>}
># 1121 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(boost::array<PodType, N>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return mutable_buffers_1(data.c_array(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes);
>}
># 1137 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(
> boost::array<const PodType, N>& data) noexcept
>{
> return const_buffers_1(data.data(), data.size() * sizeof(PodType));
>}
># 1151 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes);
>}
># 1169 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(
> const boost::array<PodType, N>& data) noexcept
>{
> return const_buffers_1(data.data(), data.size() * sizeof(PodType));
>}
># 1183 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const boost::array<PodType, N>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes);
>}
># 1201 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(
> std::array<PodType, N>& data) noexcept
>{
> return mutable_buffers_1(data.data(), data.size() * sizeof(PodType));
>}
># 1215 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline mutable_buffers_1 buffer(std::array<PodType, N>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return mutable_buffers_1(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes);
>}
># 1231 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(
> std::array<const PodType, N>& data) noexcept
>{
> return const_buffers_1(data.data(), data.size() * sizeof(PodType));
>}
># 1245 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(std::array<const PodType, N>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes);
>}
># 1261 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(
> const std::array<PodType, N>& data) noexcept
>{
> return const_buffers_1(data.data(), data.size() * sizeof(PodType));
>}
># 1275 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, std::size_t N>
>inline const_buffers_1 buffer(const std::array<PodType, N>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.data(),
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes);
>}
># 1296 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline mutable_buffers_1 buffer(
> std::vector<PodType, Allocator>& data) noexcept
>{
> return mutable_buffers_1(
> data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
>
>
>
>
>
> );
>}
># 1320 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return mutable_buffers_1(data.size() ? &data[0] : 0,
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes
>
>
>
>
>
> );
>}
># 1345 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline const_buffers_1 buffer(
> const std::vector<PodType, Allocator>& data) noexcept
>{
> return const_buffers_1(
> data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
>
>
>
>
>
> );
>}
># 1369 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename PodType, typename Allocator>
>inline const_buffers_1 buffer(
> const std::vector<PodType, Allocator>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.size() ? &data[0] : 0,
> data.size() * sizeof(PodType) < max_size_in_bytes
> ? data.size() * sizeof(PodType) : max_size_in_bytes
>
>
>
>
>
> );
>}
># 1393 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline mutable_buffers_1 buffer(
> std::basic_string<Elem, Traits, Allocator>& data) noexcept
>{
> return mutable_buffers_1(data.size() ? &data[0] : 0,
> data.size() * sizeof(Elem)
>
>
>
>
>
> );
>}
># 1417 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline mutable_buffers_1 buffer(
> std::basic_string<Elem, Traits, Allocator>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return mutable_buffers_1(data.size() ? &data[0] : 0,
> data.size() * sizeof(Elem) < max_size_in_bytes
> ? data.size() * sizeof(Elem) : max_size_in_bytes
>
>
>
>
>
> );
>}
># 1440 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline const_buffers_1 buffer(
> const std::basic_string<Elem, Traits, Allocator>& data) noexcept
>{
> return const_buffers_1(data.data(), data.size() * sizeof(Elem)
>
>
>
>
>
> );
>}
># 1463 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline const_buffers_1 buffer(
> const std::basic_string<Elem, Traits, Allocator>& data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.data(),
> data.size() * sizeof(Elem) < max_size_in_bytes
> ? data.size() * sizeof(Elem) : max_size_in_bytes
>
>
>
>
>
> );
>}
># 1487 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits>
>inline const_buffers_1 buffer(
> basic_string_view<Elem, Traits> data) noexcept
>{
> return const_buffers_1(data.size() ? &data[0] : 0,
> data.size() * sizeof(Elem)
>
>
>
>
>
> );
>}
># 1508 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits>
>inline const_buffers_1 buffer(
> basic_string_view<Elem, Traits> data,
> std::size_t max_size_in_bytes) noexcept
>{
> return const_buffers_1(data.size() ? &data[0] : 0,
> data.size() * sizeof(Elem) < max_size_in_bytes
> ? data.size() * sizeof(Elem) : max_size_in_bytes
>
>
>
>
>
> );
>}
># 1533 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>class dynamic_string_buffer
>{
>public:
>
> typedef const_buffers_1 const_buffers_type;
>
>
> typedef mutable_buffers_1 mutable_buffers_type;
># 1553 "/usr/include/boost/asio/buffer.hpp" 3 4
> explicit dynamic_string_buffer(std::basic_string<Elem, Traits, Allocator>& s,
> std::size_t maximum_size =
> (std::numeric_limits<std::size_t>::max)()) noexcept
> : string_(s),
> size_(string_.size()),
> max_size_(maximum_size)
> {
> }
>
>
>
> dynamic_string_buffer(dynamic_string_buffer&& other) noexcept
> : string_(other.string_),
> size_(other.size_),
> max_size_(other.max_size_)
> {
> }
>
>
>
> std::size_t size() const noexcept
> {
> return size_;
> }
>
>
>
>
>
>
> std::size_t max_size() const noexcept
> {
> return max_size_;
> }
>
>
>
>
>
>
> std::size_t capacity() const noexcept
> {
> return string_.capacity();
> }
># 1608 "/usr/include/boost/asio/buffer.hpp" 3 4
> const_buffers_type data() const noexcept
> {
> return const_buffers_type(boost::asio::buffer(string_, size_));
> }
># 1629 "/usr/include/boost/asio/buffer.hpp" 3 4
> mutable_buffers_type prepare(std::size_t n)
> {
> if (size () > max_size() || max_size() - size() < n)
> {
> std::length_error ex("dynamic_string_buffer too long");
> boost::asio::detail::throw_exception(ex);
> }
>
> string_.resize(size_ + n);
>
> return boost::asio::buffer(boost::asio::buffer(string_) + size_, n);
> }
># 1654 "/usr/include/boost/asio/buffer.hpp" 3 4
> void commit(std::size_t n)
> {
> size_ += (std::min)(n, string_.size() - size_);
> string_.resize(size_);
> }
># 1667 "/usr/include/boost/asio/buffer.hpp" 3 4
> void consume(std::size_t n)
> {
> std::size_t consume_length = (std::min)(n, size_);
> string_.erase(0, consume_length);
> size_ -= consume_length;
> }
>
>private:
> std::basic_string<Elem, Traits, Allocator>& string_;
> std::size_t size_;
> const std::size_t max_size_;
>};
>
>
>
>
>
>template <typename Elem, typename Allocator>
>class dynamic_vector_buffer
>{
>public:
>
> typedef const_buffers_1 const_buffers_type;
>
>
> typedef mutable_buffers_1 mutable_buffers_type;
># 1704 "/usr/include/boost/asio/buffer.hpp" 3 4
> explicit dynamic_vector_buffer(std::vector<Elem, Allocator>& v,
> std::size_t maximum_size =
> (std::numeric_limits<std::size_t>::max)()) noexcept
> : vector_(v),
> size_(vector_.size()),
> max_size_(maximum_size)
> {
> }
>
>
>
> dynamic_vector_buffer(dynamic_vector_buffer&& other) noexcept
> : vector_(other.vector_),
> size_(other.size_),
> max_size_(other.max_size_)
> {
> }
>
>
>
> std::size_t size() const noexcept
> {
> return size_;
> }
>
>
>
>
>
>
> std::size_t max_size() const noexcept
> {
> return max_size_;
> }
>
>
>
>
>
>
> std::size_t capacity() const noexcept
> {
> return vector_.capacity();
> }
># 1759 "/usr/include/boost/asio/buffer.hpp" 3 4
> const_buffers_type data() const noexcept
> {
> return const_buffers_type(boost::asio::buffer(vector_, size_));
> }
># 1780 "/usr/include/boost/asio/buffer.hpp" 3 4
> mutable_buffers_type prepare(std::size_t n)
> {
> if (size () > max_size() || max_size() - size() < n)
> {
> std::length_error ex("dynamic_vector_buffer too long");
> boost::asio::detail::throw_exception(ex);
> }
>
> vector_.resize(size_ + n);
>
> return boost::asio::buffer(boost::asio::buffer(vector_) + size_, n);
> }
># 1805 "/usr/include/boost/asio/buffer.hpp" 3 4
> void commit(std::size_t n)
> {
> size_ += (std::min)(n, vector_.size() - size_);
> vector_.resize(size_);
> }
># 1818 "/usr/include/boost/asio/buffer.hpp" 3 4
> void consume(std::size_t n)
> {
> std::size_t consume_length = (std::min)(n, size_);
> vector_.erase(vector_.begin(), vector_.begin() + consume_length);
> size_ -= consume_length;
> }
>
>private:
> std::vector<Elem, Allocator>& vector_;
> std::size_t size_;
> const std::size_t max_size_;
>};
># 1842 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename Elem, typename Traits, typename Allocator>
>inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
> std::basic_string<Elem, Traits, Allocator>& data) noexcept
>{
> return dynamic_string_buffer<Elem, Traits, Allocator>(data);
>}
>
>
>
>
>
>
>template <typename Elem, typename Traits, typename Allocator>
>inline dynamic_string_buffer<Elem, Traits, Allocator> dynamic_buffer(
> std::basic_string<Elem, Traits, Allocator>& data,
> std::size_t max_size) noexcept
>{
> return dynamic_string_buffer<Elem, Traits, Allocator>(data, max_size);
>}
>
>
>
>
>
>template <typename Elem, typename Allocator>
>inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
> std::vector<Elem, Allocator>& data) noexcept
>{
> return dynamic_vector_buffer<Elem, Allocator>(data);
>}
>
>
>
>
>
>template <typename Elem, typename Allocator>
>inline dynamic_vector_buffer<Elem, Allocator> dynamic_buffer(
> std::vector<Elem, Allocator>& data,
> std::size_t max_size) noexcept
>{
> return dynamic_vector_buffer<Elem, Allocator>(data, max_size);
>}
># 1915 "/usr/include/boost/asio/buffer.hpp" 3 4
>namespace detail {
>
>inline std::size_t buffer_copy_1(const mutable_buffer& target,
> const const_buffer& source)
>{
> using namespace std;
> std::size_t target_size = target.size();
> std::size_t source_size = source.size();
> std::size_t n = target_size < source_size ? target_size : source_size;
> if (n > 0)
> memcpy(target.data(), source.data(), n);
> return n;
>}
>
>template <typename TargetIterator, typename SourceIterator>
>inline std::size_t buffer_copy(one_buffer, one_buffer,
> TargetIterator target_begin, TargetIterator,
> SourceIterator source_begin, SourceIterator) noexcept
>{
> return (buffer_copy_1)(*target_begin, *source_begin);
>}
>
>template <typename TargetIterator, typename SourceIterator>
>inline std::size_t buffer_copy(one_buffer, one_buffer,
> TargetIterator target_begin, TargetIterator,
> SourceIterator source_begin, SourceIterator,
> std::size_t max_bytes_to_copy) noexcept
>{
> return (buffer_copy_1)(*target_begin,
> boost::asio::buffer(*source_begin, max_bytes_to_copy));
>}
>
>template <typename TargetIterator, typename SourceIterator>
>std::size_t buffer_copy(one_buffer, multiple_buffers,
> TargetIterator target_begin, TargetIterator,
> SourceIterator source_begin, SourceIterator source_end,
> std::size_t max_bytes_to_copy
> = (std::numeric_limits<std::size_t>::max)()) noexcept
>{
> std::size_t total_bytes_copied = 0;
> SourceIterator source_iter = source_begin;
>
> for (mutable_buffer target_buffer(
> boost::asio::buffer(*target_begin, max_bytes_to_copy));
> target_buffer.size() && source_iter != source_end; ++source_iter)
> {
> const_buffer source_buffer(*source_iter);
> std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
> total_bytes_copied += bytes_copied;
> target_buffer += bytes_copied;
> }
>
> return total_bytes_copied;
>}
>
>template <typename TargetIterator, typename SourceIterator>
>std::size_t buffer_copy(multiple_buffers, one_buffer,
> TargetIterator target_begin, TargetIterator target_end,
> SourceIterator source_begin, SourceIterator,
> std::size_t max_bytes_to_copy
> = (std::numeric_limits<std::size_t>::max)()) noexcept
>{
> std::size_t total_bytes_copied = 0;
> TargetIterator target_iter = target_begin;
>
> for (const_buffer source_buffer(
> boost::asio::buffer(*source_begin, max_bytes_to_copy));
> source_buffer.size() && target_iter != target_end; ++target_iter)
> {
> mutable_buffer target_buffer(*target_iter);
> std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
> total_bytes_copied += bytes_copied;
> source_buffer += bytes_copied;
> }
>
> return total_bytes_copied;
>}
>
>template <typename TargetIterator, typename SourceIterator>
>std::size_t buffer_copy(multiple_buffers, multiple_buffers,
> TargetIterator target_begin, TargetIterator target_end,
> SourceIterator source_begin, SourceIterator source_end) noexcept
>{
> std::size_t total_bytes_copied = 0;
>
> TargetIterator target_iter = target_begin;
> std::size_t target_buffer_offset = 0;
>
> SourceIterator source_iter = source_begin;
> std::size_t source_buffer_offset = 0;
>
> while (target_iter != target_end && source_iter != source_end)
> {
> mutable_buffer target_buffer =
> mutable_buffer(*target_iter) + target_buffer_offset;
>
> const_buffer source_buffer =
> const_buffer(*source_iter) + source_buffer_offset;
>
> std::size_t bytes_copied = (buffer_copy_1)(target_buffer, source_buffer);
> total_bytes_copied += bytes_copied;
>
> if (bytes_copied == target_buffer.size())
> {
> ++target_iter;
> target_buffer_offset = 0;
> }
> else
> target_buffer_offset += bytes_copied;
>
> if (bytes_copied == source_buffer.size())
> {
> ++source_iter;
> source_buffer_offset = 0;
> }
> else
> source_buffer_offset += bytes_copied;
> }
>
> return total_bytes_copied;
>}
>
>template <typename TargetIterator, typename SourceIterator>
>std::size_t buffer_copy(multiple_buffers, multiple_buffers,
> TargetIterator target_begin, TargetIterator target_end,
> SourceIterator source_begin, SourceIterator source_end,
> std::size_t max_bytes_to_copy) noexcept
>{
> std::size_t total_bytes_copied = 0;
>
> TargetIterator target_iter = target_begin;
> std::size_t target_buffer_offset = 0;
>
> SourceIterator source_iter = source_begin;
> std::size_t source_buffer_offset = 0;
>
> while (total_bytes_copied != max_bytes_to_copy
> && target_iter != target_end && source_iter != source_end)
> {
> mutable_buffer target_buffer =
> mutable_buffer(*target_iter) + target_buffer_offset;
>
> const_buffer source_buffer =
> const_buffer(*source_iter) + source_buffer_offset;
>
> std::size_t bytes_copied = (buffer_copy_1)(
> target_buffer, boost::asio::buffer(source_buffer,
> max_bytes_to_copy - total_bytes_copied));
> total_bytes_copied += bytes_copied;
>
> if (bytes_copied == target_buffer.size())
> {
> ++target_iter;
> target_buffer_offset = 0;
> }
> else
> target_buffer_offset += bytes_copied;
>
> if (bytes_copied == source_buffer.size())
> {
> ++source_iter;
> source_buffer_offset = 0;
> }
> else
> source_buffer_offset += bytes_copied;
> }
>
> return total_bytes_copied;
>}
>
>}
># 2106 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence, typename ConstBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const ConstBufferSequence& source) noexcept
>{
> return detail::buffer_copy(
> detail::buffer_sequence_cardinality<MutableBufferSequence>(),
> detail::buffer_sequence_cardinality<ConstBufferSequence>(),
> boost::asio::buffer_sequence_begin(target),
> boost::asio::buffer_sequence_end(target),
> boost::asio::buffer_sequence_begin(source),
> boost::asio::buffer_sequence_end(source));
>}
># 2143 "/usr/include/boost/asio/buffer.hpp" 3 4
>template <typename MutableBufferSequence, typename ConstBufferSequence>
>inline std::size_t buffer_copy(const MutableBufferSequence& target,
> const ConstBufferSequence& source,
> std::size_t max_bytes_to_copy) noexcept
>{
> return detail::buffer_copy(
> detail::buffer_sequence_cardinality<MutableBufferSequence>(),
> detail::buffer_sequence_cardinality<ConstBufferSequence>(),
> boost::asio::buffer_sequence_begin(target),
> boost::asio::buffer_sequence_end(target),
> boost::asio::buffer_sequence_begin(source),
> boost::asio::buffer_sequence_end(source), max_bytes_to_copy);
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 2163 "/usr/include/boost/asio/buffer.hpp" 2 3 4
># 23 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class buffer_sequence_adapter_base
>{
># 68 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 3 4
>public:
>
> enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
>
>protected:
> typedef iovec native_buffer_type;
>
> static void init_iov_base(void*& base, void* addr)
> {
> base = addr;
> }
>
> template <typename T>
> static void init_iov_base(T& base, void* addr)
> {
> base = static_cast<T>(addr);
> }
>
> static void init_native_buffer(iovec& iov,
> const boost::asio::mutable_buffer& buffer)
> {
> init_iov_base(iov.iov_base, buffer.data());
> iov.iov_len = buffer.size();
> }
>
> static void init_native_buffer(iovec& iov,
> const boost::asio::const_buffer& buffer)
> {
> init_iov_base(iov.iov_base, const_cast<void*>(buffer.data()));
> iov.iov_len = buffer.size();
> }
>
>};
>
>
>template <typename Buffer, typename Buffers>
>class buffer_sequence_adapter
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
> : count_(0), total_buffer_size_(0)
> {
> buffer_sequence_adapter::init(
> boost::asio::buffer_sequence_begin(buffer_sequence),
> boost::asio::buffer_sequence_end(buffer_sequence));
> }
>
> native_buffer_type* buffers()
> {
> return buffers_;
> }
>
> std::size_t count() const
> {
> return count_;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const Buffers& buffer_sequence)
> {
> return buffer_sequence_adapter::all_empty(
> boost::asio::buffer_sequence_begin(buffer_sequence),
> boost::asio::buffer_sequence_end(buffer_sequence));
> }
>
> static void validate(const Buffers& buffer_sequence)
> {
> buffer_sequence_adapter::validate(
> boost::asio::buffer_sequence_begin(buffer_sequence),
> boost::asio::buffer_sequence_end(buffer_sequence));
> }
>
> static Buffer first(const Buffers& buffer_sequence)
> {
> return buffer_sequence_adapter::first(
> boost::asio::buffer_sequence_begin(buffer_sequence),
> boost::asio::buffer_sequence_end(buffer_sequence));
> }
>
>private:
> template <typename Iterator>
> void init(Iterator begin, Iterator end)
> {
> Iterator iter = begin;
> for (; iter != end && count_ < max_buffers; ++iter, ++count_)
> {
> Buffer buffer(*iter);
> init_native_buffer(buffers_[count_], buffer);
> total_buffer_size_ += buffer.size();
> }
> }
>
> template <typename Iterator>
> static bool all_empty(Iterator begin, Iterator end)
> {
> Iterator iter = begin;
> std::size_t i = 0;
> for (; iter != end && i < max_buffers; ++iter, ++i)
> if (Buffer(*iter).size() > 0)
> return false;
> return true;
> }
>
> template <typename Iterator>
> static void validate(Iterator begin, Iterator end)
> {
> Iterator iter = begin;
> for (; iter != end; ++iter)
> {
> Buffer buffer(*iter);
> buffer.data();
> }
> }
>
> template <typename Iterator>
> static Buffer first(Iterator begin, Iterator end)
> {
> Iterator iter = begin;
> for (; iter != end; ++iter)
> {
> Buffer buffer(*iter);
> if (buffer.size() != 0)
> return buffer;
> }
> return Buffer();
> }
>
> native_buffer_type buffers_[max_buffers];
> std::size_t count_;
> std::size_t total_buffer_size_;
>};
>
>template <typename Buffer>
>class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffer>
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::asio::mutable_buffer& buffer_sequence)
> {
> init_native_buffer(buffer_, Buffer(buffer_sequence));
> total_buffer_size_ = buffer_sequence.size();
> }
>
> native_buffer_type* buffers()
> {
> return &buffer_;
> }
>
> std::size_t count() const
> {
> return 1;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::asio::mutable_buffer& buffer_sequence)
> {
> return buffer_sequence.size() == 0;
> }
>
> static void validate(const boost::asio::mutable_buffer& buffer_sequence)
> {
> buffer_sequence.data();
> }
>
> static Buffer first(const boost::asio::mutable_buffer& buffer_sequence)
> {
> return Buffer(buffer_sequence);
> }
>
>private:
> native_buffer_type buffer_;
> std::size_t total_buffer_size_;
>};
>
>template <typename Buffer>
>class buffer_sequence_adapter<Buffer, boost::asio::const_buffer>
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::asio::const_buffer& buffer_sequence)
> {
> init_native_buffer(buffer_, Buffer(buffer_sequence));
> total_buffer_size_ = buffer_sequence.size();
> }
>
> native_buffer_type* buffers()
> {
> return &buffer_;
> }
>
> std::size_t count() const
> {
> return 1;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::asio::const_buffer& buffer_sequence)
> {
> return buffer_sequence.size() == 0;
> }
>
> static void validate(const boost::asio::const_buffer& buffer_sequence)
> {
> buffer_sequence.data();
> }
>
> static Buffer first(const boost::asio::const_buffer& buffer_sequence)
> {
> return Buffer(buffer_sequence);
> }
>
>private:
> native_buffer_type buffer_;
> std::size_t total_buffer_size_;
>};
>
>
>
>template <typename Buffer>
>class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> init_native_buffer(buffer_, Buffer(buffer_sequence));
> total_buffer_size_ = buffer_sequence.size();
> }
>
> native_buffer_type* buffers()
> {
> return &buffer_;
> }
>
> std::size_t count() const
> {
> return 1;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> return buffer_sequence.size() == 0;
> }
>
> static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> buffer_sequence.data();
> }
>
> static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
> {
> return Buffer(buffer_sequence);
> }
>
>private:
> native_buffer_type buffer_;
> std::size_t total_buffer_size_;
>};
>
>template <typename Buffer>
>class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::asio::const_buffers_1& buffer_sequence)
> {
> init_native_buffer(buffer_, Buffer(buffer_sequence));
> total_buffer_size_ = buffer_sequence.size();
> }
>
> native_buffer_type* buffers()
> {
> return &buffer_;
> }
>
> std::size_t count() const
> {
> return 1;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
> {
> return buffer_sequence.size() == 0;
> }
>
> static void validate(const boost::asio::const_buffers_1& buffer_sequence)
> {
> buffer_sequence.data();
> }
>
> static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
> {
> return Buffer(buffer_sequence);
> }
>
>private:
> native_buffer_type buffer_;
> std::size_t total_buffer_size_;
>};
>
>
>
>template <typename Buffer, typename Elem>
>class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const boost::array<Elem, 2>& buffer_sequence)
> {
> init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
> init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
> total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
> }
>
> native_buffer_type* buffers()
> {
> return buffers_;
> }
>
> std::size_t count() const
> {
> return 2;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
> {
> return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
> }
>
> static void validate(const boost::array<Elem, 2>& buffer_sequence)
> {
> buffer_sequence[0].data();
> buffer_sequence[1].data();
> }
>
> static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
> {
> return Buffer(buffer_sequence[0].size() != 0
> ? buffer_sequence[0] : buffer_sequence[1]);
> }
>
>private:
> native_buffer_type buffers_[2];
> std::size_t total_buffer_size_;
>};
>
>
>
>template <typename Buffer, typename Elem>
>class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
> : buffer_sequence_adapter_base
>{
>public:
> explicit buffer_sequence_adapter(
> const std::array<Elem, 2>& buffer_sequence)
> {
> init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
> init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
> total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
> }
>
> native_buffer_type* buffers()
> {
> return buffers_;
> }
>
> std::size_t count() const
> {
> return 2;
> }
>
> std::size_t total_size() const
> {
> return total_buffer_size_;
> }
>
> bool all_empty() const
> {
> return total_buffer_size_ == 0;
> }
>
> static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
> {
> return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
> }
>
> static void validate(const std::array<Elem, 2>& buffer_sequence)
> {
> buffer_sequence[0].data();
> buffer_sequence[1].data();
> }
>
> static Buffer first(const std::array<Elem, 2>& buffer_sequence)
> {
> return Buffer(buffer_sequence[0].size() != 0
> ? buffer_sequence[0] : buffer_sequence[1]);
> }
>
>private:
> native_buffer_type buffers_[2];
> std::size_t total_buffer_size_;
>};
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 541 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/buffer_sequence_adapter.ipp" 1 3 4
># 544 "/usr/include/boost/asio/detail/buffer_sequence_adapter.hpp" 2 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class reactive_null_buffers_op : public reactor_op
>{
>public:
> struct ptr { Handler* h; reactive_null_buffers_op* v; reactive_null_buffers_op* p; ~ptr() { reset(); } static reactive_null_buffers_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_null_buffers_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_null_buffers_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_null_buffers_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_null_buffers_op*>(v), 1); v = 0; } } };
>
> reactive_null_buffers_op(Handler& handler)
> : reactor_op(&reactive_null_buffers_op::do_perform,
> &reactive_null_buffers_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static status do_perform(reactor_op*)
> {
> return done;
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 91 "/usr/include/boost/asio/detail/reactive_null_buffers_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/socket_holder.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/socket_holder.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/socket_ops.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace socket_ops {
>
>
>enum
>{
>
> user_set_non_blocking = 1,
>
>
> internal_non_blocking = 2,
>
>
> non_blocking = user_set_non_blocking | internal_non_blocking,
>
>
> enable_connection_aborted = 4,
>
>
> user_set_linger = 8,
>
>
> stream_oriented = 16,
>
>
> datagram_oriented = 32,
>
>
> possible_dup = 64
>};
>
>typedef unsigned char state_type;
>
>struct noop_deleter { void operator()(void*) {} };
>typedef shared_ptr<void> shared_cancel_token_type;
>typedef weak_ptr<void> weak_cancel_token_type;
>
>
>
>inline socket_type accept(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
>
>inline socket_type sync_accept(socket_type s,
> state_type state, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
># 83 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_accept(socket_type s,
> state_type state, socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, socket_type& new_socket);
>
>
>
>inline int bind(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline int close(socket_type s, state_type& state,
> bool destruction, boost::system::error_code& ec);
>
>inline bool set_user_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec);
>
>inline bool set_internal_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec);
>
>inline int shutdown(socket_type s,
> int what, boost::system::error_code& ec);
>
>inline int connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline void sync_connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
># 117 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_connect(socket_type s,
> boost::system::error_code& ec);
>
>inline int socketpair(int af, int type, int protocol,
> socket_type sv[2], boost::system::error_code& ec);
>
>inline bool sockatmark(socket_type s, boost::system::error_code& ec);
>
>inline size_t available(socket_type s, boost::system::error_code& ec);
>
>inline int listen(socket_type s,
> int backlog, boost::system::error_code& ec);
>
>
>
>
>typedef iovec buf;
>
>
>inline void init_buf(buf& b, void* data, size_t size);
>
>inline void init_buf(buf& b, const void* data, size_t size);
>
>inline signed_size_type recv(socket_type s, buf* bufs,
> size_t count, int flags, boost::system::error_code& ec);
>
>inline size_t sync_recv(socket_type s, state_type state, buf* bufs,
> size_t count, int flags, bool all_empty, boost::system::error_code& ec);
># 154 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_recv(socket_type s,
> buf* bufs, size_t count, int flags, bool is_stream,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type recvfrom(socket_type s, buf* bufs,
> size_t count, int flags, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
>
>inline size_t sync_recvfrom(socket_type s, state_type state,
> buf* bufs, size_t count, int flags, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
># 176 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_recvfrom(socket_type s,
> buf* bufs, size_t count, int flags,
> socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type recvmsg(socket_type s, buf* bufs,
> size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec);
>
>inline size_t sync_recvmsg(socket_type s, state_type state,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec);
># 199 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_recvmsg(socket_type s,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type send(socket_type s, const buf* bufs,
> size_t count, int flags, boost::system::error_code& ec);
>
>inline size_t sync_send(socket_type s, state_type state,
> const buf* bufs, size_t count, int flags,
> bool all_empty, boost::system::error_code& ec);
># 220 "/usr/include/boost/asio/detail/socket_ops.hpp" 3 4
>inline bool non_blocking_send(socket_type s,
> const buf* bufs, size_t count, int flags,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline signed_size_type sendto(socket_type s, const buf* bufs,
> size_t count, int flags, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>inline size_t sync_sendto(socket_type s, state_type state,
> const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec);
>
>
>
>inline bool non_blocking_sendto(socket_type s,
> const buf* bufs, size_t count, int flags,
> const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred);
>
>
>
>inline socket_type socket(int af, int type, int protocol,
> boost::system::error_code& ec);
>
>inline int setsockopt(socket_type s, state_type& state,
> int level, int optname, const void* optval,
> std::size_t optlen, boost::system::error_code& ec);
>
>inline int getsockopt(socket_type s, state_type state,
> int level, int optname, void* optval,
> size_t* optlen, boost::system::error_code& ec);
>
>inline int getpeername(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, bool cached, boost::system::error_code& ec);
>
>inline int getsockname(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec);
>
>inline int ioctl(socket_type s, state_type& state,
> int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
>
>inline int select(int nfds, fd_set* readfds, fd_set* writefds,
> fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);
>
>inline int poll_read(socket_type s,
> state_type state, int msec, boost::system::error_code& ec);
>
>inline int poll_write(socket_type s,
> state_type state, int msec, boost::system::error_code& ec);
>
>inline int poll_error(socket_type s,
> state_type state, int msec, boost::system::error_code& ec);
>
>inline int poll_connect(socket_type s,
> int msec, boost::system::error_code& ec);
>
>
>
>inline const char* inet_ntop(int af, const void* src, char* dest,
> size_t length, unsigned long scope_id, boost::system::error_code& ec);
>
>inline int inet_pton(int af, const char* src, void* dest,
> unsigned long* scope_id, boost::system::error_code& ec);
>
>inline int gethostname(char* name,
> int namelen, boost::system::error_code& ec);
>
>
>
>inline boost::system::error_code getaddrinfo(const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec);
>
>inline boost::system::error_code background_getaddrinfo(
> const weak_cancel_token_type& cancel_token, const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec);
>
>inline void freeaddrinfo(addrinfo_type* ai);
>
>inline boost::system::error_code getnameinfo(
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int flags, boost::system::error_code& ec);
>
>inline boost::system::error_code sync_getnameinfo(
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec);
>
>inline boost::system::error_code background_getnameinfo(
> const weak_cancel_token_type& cancel_token,
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec);
>
>
>
>inline u_long_type network_to_host_long(u_long_type value);
>
>inline u_long_type host_to_network_long(u_long_type value);
>
>inline u_short_type network_to_host_short(u_short_type value);
>
>inline u_short_type host_to_network_short(u_short_type value);
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 334 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
># 1 "/usr/include/c++/8/cctype" 1 3 4
># 39 "/usr/include/c++/8/cctype" 3 4
> 
># 40 "/usr/include/c++/8/cctype" 3
># 21 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/8/cstdio" 1 3 4
># 39 "/usr/include/c++/8/cstdio" 3 4
> 
># 40 "/usr/include/c++/8/cstdio" 3
># 22 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/8/cstdlib" 1 3 4
># 39 "/usr/include/c++/8/cstdlib" 3 4
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 23 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 24 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 1 "/usr/include/c++/8/cerrno" 1 3 4
># 39 "/usr/include/c++/8/cerrno" 3 4
> 
># 40 "/usr/include/c++/8/cerrno" 3
># 25 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/socket_ops.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 44 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 45 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace socket_ops {
># 66 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>inline void clear_last_error()
>{
>
>
>
> (*__errno_location ()) = 0;
>
>}
>
>
>
>template <typename ReturnType>
>inline ReturnType error_wrapper(ReturnType return_value,
> boost::system::error_code& ec)
>{
>
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> return return_value;
>}
>
>template <typename SockLenType>
>inline socket_type call_accept(SockLenType msghdr::*,
> socket_type s, socket_addr_type* addr, std::size_t* addrlen)
>{
> SockLenType tmp_addrlen = addrlen ? (SockLenType)*addrlen : 0;
> socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0);
> if (addrlen)
> *addrlen = (std::size_t)tmp_addrlen;
> return result;
>}
>
>socket_type accept(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return invalid_socket;
> }
>
> clear_last_error();
>
> socket_type new_s = error_wrapper(call_accept(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (new_s == invalid_socket)
> return new_s;
># 129 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ec = boost::system::error_code();
> return new_s;
>}
>
>socket_type sync_accept(socket_type s, state_type state,
> socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec)
>{
>
> for (;;)
> {
>
> socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
>
>
> if (new_socket != invalid_socket)
> return new_socket;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> {
> if (state & user_set_non_blocking)
> return invalid_socket;
>
> }
> else if (ec == boost::asio::error::connection_aborted)
> {
> if (state & enable_connection_aborted)
> return invalid_socket;
>
> }
>
> else if (ec.value() == 71)
> {
> if (state & enable_connection_aborted)
> return invalid_socket;
>
> }
>
> else
> return invalid_socket;
>
>
> if (socket_ops::poll_read(s, 0, -1, ec) < 0)
> return invalid_socket;
> }
>}
># 224 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_accept(socket_type s,
> state_type state, socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, socket_type& new_socket)
>{
> for (;;)
> {
>
> new_socket = socket_ops::accept(s, addr, addrlen, ec);
>
>
> if (new_socket != invalid_socket)
> return true;
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> {
>
> }
> else if (ec == boost::asio::error::connection_aborted)
> {
> if (state & enable_connection_aborted)
> return true;
>
> }
>
> else if (ec.value() == 71)
> {
> if (state & enable_connection_aborted)
> return true;
>
> }
>
> else
> return true;
>
> return false;
> }
>}
>
>
>
>template <typename SockLenType>
>inline int call_bind(SockLenType msghdr::*,
> socket_type s, const socket_addr_type* addr, std::size_t addrlen)
>{
> return ::bind(s, addr, (SockLenType)addrlen);
>}
>
>int bind(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(call_bind(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int close(socket_type s, state_type& state,
> bool destruction, boost::system::error_code& ec)
>{
> int result = 0;
> if (s != invalid_socket)
> {
>
>
>
> if (destruction && (state & user_set_linger))
> {
> ::linger opt;
> opt.l_onoff = 0;
> opt.l_linger = 0;
> boost::system::error_code ignored_ec;
> socket_ops::setsockopt(s, state, 1,
> 13, &opt, sizeof(opt), ignored_ec);
> }
>
> clear_last_error();
>
>
>
> result = error_wrapper(::close(s), ec);
>
>
> if (result != 0
> && (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again))
> {
># 339 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ioctl_arg_type arg = 0;
> ::ioctl(s, 0x5421, &arg);
>
>
> state &= ~non_blocking;
>
> clear_last_error();
>
>
>
> result = error_wrapper(::close(s), ec);
>
> }
> }
>
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>bool set_user_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> clear_last_error();
># 381 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(s, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= user_set_non_blocking;
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> return true;
> }
>
> return false;
>}
>
>bool set_internal_non_blocking(socket_type s,
> state_type& state, bool value, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> if (!value && (state & user_set_non_blocking))
> {
>
>
>
> ec = boost::asio::error::invalid_argument;
> return false;
> }
>
> clear_last_error();
># 434 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(s, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= internal_non_blocking;
> else
> state &= ~internal_non_blocking;
> return true;
> }
>
> return false;
>}
>
>int shutdown(socket_type s, int what, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(::shutdown(s, what), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>template <typename SockLenType>
>inline int call_connect(SockLenType msghdr::*,
> socket_type s, const socket_addr_type* addr, std::size_t addrlen)
>{
> return ::connect(s, addr, (SockLenType)addrlen);
>}
>
>int connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(call_connect(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
>
> else if (ec == boost::asio::error::try_again)
> ec = boost::asio::error::no_buffer_space;
>
> return result;
>}
>
>void sync_connect(socket_type s, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
>
> socket_ops::connect(s, addr, addrlen, ec);
> if (ec != boost::asio::error::in_progress
> && ec != boost::asio::error::would_block)
> {
>
> return;
> }
>
>
> if (socket_ops::poll_connect(s, -1, ec) < 0)
> return;
>
>
> int connect_error = 0;
> size_t connect_error_len = sizeof(connect_error);
> if (socket_ops::getsockopt(s, 0, 1, 4,
> &connect_error, &connect_error_len, ec) == socket_error_retval)
> return;
>
>
> ec = boost::system::error_code(connect_error,
> boost::asio::error::get_system_category());
>}
># 558 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
>{
># 578 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x004;
> fds.revents = 0;
> int ready = ::poll(&fds, 1, 0);
>
>
>
> if (ready == 0)
> {
>
> return false;
> }
>
>
> int connect_error = 0;
> size_t connect_error_len = sizeof(connect_error);
> if (socket_ops::getsockopt(s, 0, 1, 4,
> &connect_error, &connect_error_len, ec) == 0)
> {
> if (connect_error)
> {
> ec = boost::system::error_code(connect_error,
> boost::asio::error::get_system_category());
> }
> else
> ec = boost::system::error_code();
> }
>
> return true;
>}
>
>int socketpair(int af, int type, int protocol,
> socket_type sv[2], boost::system::error_code& ec)
>{
># 621 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int result = error_wrapper(::socketpair(af, type, protocol, sv), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>bool sockatmark(socket_type s, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
>
> ioctl_arg_type value = 0;
>
>
>
> int result = error_wrapper(::ioctl(s, 0x8905, &value), ec);
>
> if (result == 0)
> ec = boost::system::error_code();
>
> if (ec.value() == 25)
> ec = boost::asio::error::not_socket;
>
>
>
>
>
>
>
> return ec ? false : value != 0;
>}
>
>size_t available(socket_type s, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
> ioctl_arg_type value = 0;
>
>
>
> int result = error_wrapper(::ioctl(s, 0x541B, &value), ec);
>
> if (result == 0)
> ec = boost::system::error_code();
>
> if (ec.value() == 25)
> ec = boost::asio::error::not_socket;
>
>
> return ec ? static_cast<size_t>(0) : static_cast<size_t>(value);
>}
>
>int listen(socket_type s, int backlog, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(::listen(s, backlog), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>inline void init_buf_iov_base(void*& base, void* addr)
>{
> base = addr;
>}
>
>template <typename T>
>inline void init_buf_iov_base(T& base, void* addr)
>{
> base = static_cast<T>(addr);
>}
>
>
>
>
>typedef iovec buf;
>
>
>void init_buf(buf& b, void* data, size_t size)
>{
>
>
>
>
> init_buf_iov_base(b.iov_base, data);
> b.iov_len = size;
>
>}
>
>void init_buf(buf& b, const void* data, size_t size)
>{
>
>
>
>
> init_buf_iov_base(b.iov_base, const_cast<void*>(data));
> b.iov_len = size;
>
>}
>
>inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
>{
> name = addr;
>}
>
>inline void init_msghdr_msg_name(void*& name, const socket_addr_type* addr)
>{
> name = const_cast<socket_addr_type*>(addr);
>}
>
>template <typename T>
>inline void init_msghdr_msg_name(T& name, socket_addr_type* addr)
>{
> name = reinterpret_cast<T>(addr);
>}
>
>template <typename T>
>inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
>{
> name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
>}
>
>signed_size_type recv(socket_type s, buf* bufs, size_t count,
> int flags, boost::system::error_code& ec)
>{
> clear_last_error();
># 781 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> msg.msg_iov = bufs;
> msg.msg_iovlen = static_cast<int>(count);
> signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_recv(socket_type s, state_type state, buf* bufs,
> size_t count, int flags, bool all_empty, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty && (state & stream_oriented))
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
>
>
> if (bytes > 0)
> return bytes;
>
>
> if ((state & stream_oriented) && bytes == 0)
> {
> ec = boost::asio::error::eof;
> return 0;
> }
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_read(s, 0, -1, ec) < 0)
> return 0;
> }
>}
># 870 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_recv(socket_type s,
> buf* bufs, size_t count, int flags, bool is_stream,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
>
>
> if (is_stream && bytes == 0)
> {
> ec = boost::asio::error::eof;
> return true;
> }
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
> int flags, socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec)
>{
> clear_last_error();
># 935 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> init_msghdr_msg_name(msg.msg_name, addr);
> msg.msg_namelen = static_cast<int>(*addrlen);
> msg.msg_iov = bufs;
> msg.msg_iovlen = static_cast<int>(count);
> signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
> *addrlen = msg.msg_namelen;
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
> size_t count, int flags, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvfrom(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_read(s, 0, -1, ec) < 0)
> return 0;
> }
>}
># 1007 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_recvfrom(socket_type s,
> buf* bufs, size_t count, int flags,
> socket_addr_type* addr, std::size_t* addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvfrom(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
> int in_flags, int& out_flags, boost::system::error_code& ec)
>{
> clear_last_error();
>
>
>
>
> msghdr msg = msghdr();
> msg.msg_iov = bufs;
> msg.msg_iovlen = static_cast<int>(count);
> signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
> if (result >= 0)
> {
> ec = boost::system::error_code();
> out_flags = msg.msg_flags;
> }
> else
> out_flags = 0;
> return result;
>
>}
>
>size_t sync_recvmsg(socket_type s, state_type state,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvmsg(
> s, bufs, count, in_flags, out_flags, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_read(s, 0, -1, ec) < 0)
> return 0;
> }
>}
># 1124 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_recvmsg(socket_type s,
> buf* bufs, size_t count, int in_flags, int& out_flags,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::recvmsg(
> s, bufs, count, in_flags, out_flags, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type send(socket_type s, const buf* bufs, size_t count,
> int flags, boost::system::error_code& ec)
>{
> clear_last_error();
># 1178 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> msg.msg_iov = const_cast<buf*>(bufs);
> msg.msg_iovlen = static_cast<int>(count);
>
> flags |= MSG_NOSIGNAL;
>
> signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_send(socket_type s, state_type state, const buf* bufs,
> size_t count, int flags, bool all_empty, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty && (state & stream_oriented))
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_write(s, 0, -1, ec) < 0)
> return 0;
> }
>}
># 1251 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>bool non_blocking_send(socket_type s,
> const buf* bufs, size_t count, int flags,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
> int flags, const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec)
>{
> clear_last_error();
># 1305 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> msghdr msg = msghdr();
> init_msghdr_msg_name(msg.msg_name, addr);
> msg.msg_namelen = static_cast<int>(addrlen);
> msg.msg_iov = const_cast<buf*>(bufs);
> msg.msg_iovlen = static_cast<int>(count);
>
> flags |= MSG_NOSIGNAL;
>
> signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
> size_t count, int flags, const socket_addr_type* addr,
> std::size_t addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::sendto(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (bytes >= 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (socket_ops::poll_write(s, 0, -1, ec) < 0)
> return 0;
> }
>}
>
>
>
>bool non_blocking_sendto(socket_type s,
> const buf* bufs, size_t count, int flags,
> const socket_addr_type* addr, std::size_t addrlen,
> boost::system::error_code& ec, size_t& bytes_transferred)
>{
> for (;;)
> {
>
> signed_size_type bytes = socket_ops::sendto(
> s, bufs, count, flags, addr, addrlen, ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>
>
>socket_type socket(int af, int type, int protocol,
> boost::system::error_code& ec)
>{
> clear_last_error();
># 1429 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int s = error_wrapper(::socket(af, type, protocol), ec);
> if (s >= 0)
> ec = boost::system::error_code();
> return s;
>
>}
>
>template <typename SockLenType>
>inline int call_setsockopt(SockLenType msghdr::*,
> socket_type s, int level, int optname,
> const void* optval, std::size_t optlen)
>{
> return ::setsockopt(s, level, optname,
> (const char*)optval, (SockLenType)optlen);
>}
>
>int setsockopt(socket_type s, state_type& state, int level, int optname,
> const void* optval, std::size_t optlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level && optname == always_fail_option)
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level
> && optname == enable_connection_aborted_option)
> {
> if (optlen != sizeof(int))
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> if (*static_cast<const int*>(optval))
> state |= enable_connection_aborted;
> else
> state &= ~enable_connection_aborted;
> ec = boost::system::error_code();
> return 0;
> }
>
> if (level == 1 && optname == 13)
> state |= user_set_linger;
># 1498 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int result = error_wrapper(call_setsockopt(&msghdr::msg_namelen,
> s, level, optname, optval, optlen), ec);
> if (result == 0)
> {
> ec = boost::system::error_code();
># 1516 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> }
>
> return result;
>
>}
>
>template <typename SockLenType>
>inline int call_getsockopt(SockLenType msghdr::*,
> socket_type s, int level, int optname,
> void* optval, std::size_t* optlen)
>{
> SockLenType tmp_optlen = (SockLenType)*optlen;
> int result = ::getsockopt(s, level, optname, (char*)optval, &tmp_optlen);
> *optlen = (std::size_t)tmp_optlen;
> return result;
>}
>
>int getsockopt(socket_type s, state_type state, int level, int optname,
> void* optval, size_t* optlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level && optname == always_fail_option)
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> if (level == custom_socket_option_level
> && optname == enable_connection_aborted_option)
> {
> if (*optlen != sizeof(int))
> {
> ec = boost::asio::error::invalid_argument;
> return socket_error_retval;
> }
>
> *static_cast<int*>(optval) = (state & enable_connection_aborted) ? 1 : 0;
> ec = boost::system::error_code();
> return 0;
> }
># 1611 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
> s, level, optname, optval, optlen), ec);
>
> if (result == 0 && level == 1 && *optlen == sizeof(int)
> && (optname == 7 || optname == 8))
> {
>
>
>
>
>
> *static_cast<int*>(optval) /= 2;
> }
>
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>template <typename SockLenType>
>inline int call_getpeername(SockLenType msghdr::*,
> socket_type s, socket_addr_type* addr, std::size_t* addrlen)
>{
> SockLenType tmp_addrlen = (SockLenType)*addrlen;
> int result = ::getpeername(s, addr, &tmp_addrlen);
> *addrlen = (std::size_t)tmp_addrlen;
> return result;
>}
>
>int getpeername(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, bool cached, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1675 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> (void)cached;
>
>
>
> clear_last_error();
> int result = error_wrapper(call_getpeername(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>template <typename SockLenType>
>inline int call_getsockname(SockLenType msghdr::*,
> socket_type s, socket_addr_type* addr, std::size_t* addrlen)
>{
> SockLenType tmp_addrlen = (SockLenType)*addrlen;
> int result = ::getsockname(s, addr, &tmp_addrlen);
> *addrlen = (std::size_t)tmp_addrlen;
> return result;
>}
>
>int getsockname(socket_type s, socket_addr_type* addr,
> std::size_t* addrlen, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
> int result = error_wrapper(call_getsockname(
> &msghdr::msg_namelen, s, addr, addrlen), ec);
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int ioctl(socket_type s, state_type& state, int cmd,
> ioctl_arg_type* arg, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
>
> clear_last_error();
>
>
>
>
>
>
>
> int result = error_wrapper(::ioctl(s, cmd, arg), ec);
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
>
>
>
>
>
>
> if (cmd == static_cast<int>(0x5421))
> {
> if (*arg)
> {
> state |= user_set_non_blocking;
> }
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> }
> }
>
> return result;
>}
>
>int select(int nfds, fd_set* readfds, fd_set* writefds,
> fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
>{
> clear_last_error();
># 1794 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int result = error_wrapper(::select(nfds, readfds,
> writefds, exceptfds, timeout), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>}
>
>int poll_read(socket_type s, state_type state,
> int msec, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1838 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x001;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : msec;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
>
>
>
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_write(socket_type s, state_type state,
> int msec, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1892 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x004;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : msec;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
>
>
>
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_error(socket_type s, state_type state,
> int msec, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 1946 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x002 | 0x008 | 0x010;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : msec;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
>
>
>
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_connect(socket_type s, int msec, boost::system::error_code& ec)
>{
> if (s == invalid_socket)
> {
> ec = boost::asio::error::bad_descriptor;
> return socket_error_retval;
> }
># 2000 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> pollfd fds;
> fds.fd = s;
> fds.events = 0x004;
> fds.revents = 0;
> clear_last_error();
> int result = error_wrapper(::poll(&fds, 1, msec), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>
>
>
>}
>
>
>
>const char* inet_ntop(int af, const void* src, char* dest, size_t length,
> unsigned long scope_id, boost::system::error_code& ec)
>{
> clear_last_error();
># 2111 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> const char* result = error_wrapper(::inet_ntop(
> af, src, dest, static_cast<int>(length)), ec);
> if (result == 0 && !ec)
> ec = boost::asio::error::invalid_argument;
> if (result != 0 && af == 10 && scope_id != 0)
> {
> using namespace std;
> char if_name[16 + 1] = "%";
> const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
> bool is_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xfe)
> && ((ipv6_address->__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
> bool is_multicast_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xff)
> && ((ipv6_address->__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
> if ((!is_link_local && !is_multicast_link_local)
> || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
> sprintf(if_name + 1, "%lu", scope_id);
> strcat(dest, if_name);
> }
> return result;
>
>}
>
>int inet_pton(int af, const char* src, void* dest,
> unsigned long* scope_id, boost::system::error_code& ec)
>{
> clear_last_error();
># 2342 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> using namespace std;
>
>
>
> const bool is_v6 = (af == 10);
> const char* if_name = is_v6 ? strchr(src, '%') : 0;
> char src_buf[max_addr_v6_str_len + 1];
> const char* src_ptr = src;
> if (if_name != 0)
> {
> if (if_name - src > max_addr_v6_str_len)
> {
> ec = boost::asio::error::invalid_argument;
> return 0;
> }
> memcpy(src_buf, src, if_name - src);
> src_buf[if_name - src] = 0;
> src_ptr = src_buf;
> }
>
> int result = error_wrapper(::inet_pton(af, src_ptr, dest), ec);
> if (result <= 0 && !ec)
> ec = boost::asio::error::invalid_argument;
> if (result > 0 && is_v6 && scope_id)
> {
> using namespace std;
> *scope_id = 0;
> if (if_name != 0)
> {
> in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
> bool is_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xfe)
> && ((ipv6_address->__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
> bool is_multicast_link_local = ((ipv6_address->__in6_u.__u6_addr8[0] == 0xff)
> && ((ipv6_address->__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
> if (is_link_local || is_multicast_link_local)
> *scope_id = if_nametoindex(if_name + 1);
> if (*scope_id == 0)
> *scope_id = atoi(if_name + 1);
> }
> }
> return result;
>
>}
>
>int gethostname(char* name, int namelen, boost::system::error_code& ec)
>{
> clear_last_error();
># 2419 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int result = error_wrapper(::gethostname(name, namelen), ec);
>
>
>
>
> return result;
>
>}
># 3274 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
>inline boost::system::error_code translate_addrinfo_error(int error)
>{
> switch (error)
> {
> case 0:
> return boost::system::error_code();
> case -3:
> return boost::asio::error::host_not_found_try_again;
> case -1:
> return boost::asio::error::invalid_argument;
> case -4:
> return boost::asio::error::no_recovery;
> case -6:
> return boost::asio::error::address_family_not_supported;
> case -10:
> return boost::asio::error::no_memory;
> case -2:
>
> case -9:
>
>
> case -5:
>
> return boost::asio::error::host_not_found;
> case -8:
> return boost::asio::error::service_not_found;
> case -7:
> return boost::asio::error::socket_type_not_supported;
> default:
>
>
>
>
> return boost::system::error_code(
> (*__errno_location ()), boost::asio::error::get_system_category());
>
> }
>}
>
>boost::system::error_code getaddrinfo(const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec)
>{
> host = (host && *host) ? host : 0;
> service = (service && *service) ? service : 0;
> clear_last_error();
># 3344 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> int error = ::getaddrinfo(host, service, &hints, result);
># 3376 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> return ec = translate_addrinfo_error(error);
>
>}
>
>boost::system::error_code background_getaddrinfo(
> const weak_cancel_token_type& cancel_token, const char* host,
> const char* service, const addrinfo_type& hints,
> addrinfo_type** result, boost::system::error_code& ec)
>{
> if (cancel_token.expired())
> ec = boost::asio::error::operation_aborted;
> else
> socket_ops::getaddrinfo(host, service, hints, result, ec);
> return ec;
>}
>
>void freeaddrinfo(addrinfo_type* ai)
>{
># 3414 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> ::freeaddrinfo(ai);
>
>}
>
>boost::system::error_code getnameinfo(const socket_addr_type* addr,
> std::size_t addrlen, char* host, std::size_t hostlen,
> char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
>{
># 3458 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> clear_last_error();
> int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
> return ec = translate_addrinfo_error(error);
>
>}
>
>boost::system::error_code sync_getnameinfo(
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec)
>{
>
>
> int flags = (sock_type == SOCK_DGRAM) ? 16 : 0;
> socket_ops::getnameinfo(addr, addrlen, host,
> hostlen, serv, servlen, flags, ec);
> if (ec)
> {
> socket_ops::getnameinfo(addr, addrlen, host, hostlen,
> serv, servlen, flags | 2, ec);
> }
>
> return ec;
>}
>
>boost::system::error_code background_getnameinfo(
> const weak_cancel_token_type& cancel_token,
> const socket_addr_type* addr, std::size_t addrlen,
> char* host, std::size_t hostlen, char* serv,
> std::size_t servlen, int sock_type, boost::system::error_code& ec)
>{
> if (cancel_token.expired())
> {
> ec = boost::asio::error::operation_aborted;
> }
> else
> {
>
>
> int flags = (sock_type == SOCK_DGRAM) ? 16 : 0;
> socket_ops::getnameinfo(addr, addrlen, host,
> hostlen, serv, servlen, flags, ec);
> if (ec)
> {
> socket_ops::getnameinfo(addr, addrlen, host, hostlen,
> serv, servlen, flags | 2, ec);
> }
> }
>
> return ec;
>}
>
>
>
>u_long_type network_to_host_long(u_long_type value)
>{
># 3522 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> return __bswap_32 (value);
>
>}
>
>u_long_type host_to_network_long(u_long_type value)
>{
># 3537 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 3 4
> return __bswap_32 (value);
>
>}
>
>u_short_type network_to_host_short(u_short_type value)
>{
>
>
>
>
>
>
> return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (value); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>
>}
>
>u_short_type host_to_network_short(u_short_type value)
>{
>
>
>
>
>
>
>
> return (__extension__ ({ unsigned short int __v, __x = (unsigned short int) (value); if (__builtin_constant_p (__x)) __v = ((unsigned short int) ((((__x) >> 8) & 0xff) | (((__x) & 0xff) << 8))); else __asm__ ("rorw $8, %w0" : "=r" (__v) : "0" (__x) : "cc"); __v; }));
>
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 3572 "/usr/include/boost/asio/detail/impl/socket_ops.ipp" 2 3 4
># 337 "/usr/include/boost/asio/detail/socket_ops.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/socket_holder.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/socket_holder.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class socket_holder
> : private noncopyable
>{
>public:
>
> socket_holder()
> : socket_(invalid_socket)
> {
> }
>
>
> explicit socket_holder(socket_type s)
> : socket_(s)
> {
> }
>
>
> ~socket_holder()
> {
> if (socket_ != invalid_socket)
> {
> boost::system::error_code ec;
> socket_ops::state_type state = 0;
> socket_ops::close(socket_, state, true, ec);
> }
> }
>
>
> socket_type get() const
> {
> return socket_;
> }
>
>
> void reset()
> {
> if (socket_ != invalid_socket)
> {
> boost::system::error_code ec;
> socket_ops::state_type state = 0;
> socket_ops::close(socket_, state, true, ec);
> socket_ = invalid_socket;
> }
> }
>
>
> void reset(socket_type s)
> {
> reset();
> socket_ = s;
> }
>
>
> socket_type release()
> {
> socket_type tmp = socket_;
> socket_ = invalid_socket;
> return tmp;
> }
>
>private:
>
> socket_type socket_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 99 "/usr/include/boost/asio/detail/socket_holder.hpp" 2 3 4
># 25 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Socket, typename Protocol>
>class reactive_socket_accept_op_base : public reactor_op
>{
>public:
> reactive_socket_accept_op_base(socket_type socket,
> socket_ops::state_type state, Socket& peer, const Protocol& protocol,
> typename Protocol::endpoint* peer_endpoint, func_type complete_func)
> : reactor_op(&reactive_socket_accept_op_base::do_perform, complete_func),
> socket_(socket),
> state_(state),
> peer_(peer),
> protocol_(protocol),
> peer_endpoint_(peer_endpoint),
> addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_accept_op_base* o(
> static_cast<reactive_socket_accept_op_base*>(base));
>
> socket_type new_socket = invalid_socket;
> status result = socket_ops::non_blocking_accept(o->socket_,
> o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
> o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket)
> ? done : not_done;
> o->new_socket_.reset(new_socket);
>
> (void)0;
>
> return result;
> }
>
> void do_assign()
> {
> if (new_socket_.get() != invalid_socket)
> {
> if (peer_endpoint_)
> peer_endpoint_->resize(addrlen_);
> peer_.assign(protocol_, new_socket_.get(), ec_);
> if (!ec_)
> new_socket_.release();
> }
> }
>
>private:
> socket_type socket_;
> socket_ops::state_type state_;
> socket_holder new_socket_;
> Socket& peer_;
> Protocol protocol_;
> typename Protocol::endpoint* peer_endpoint_;
> std::size_t addrlen_;
>};
>
>template <typename Socket, typename Protocol, typename Handler>
>class reactive_socket_accept_op :
> public reactive_socket_accept_op_base<Socket, Protocol>
>{
>public:
> struct ptr { Handler* h; reactive_socket_accept_op* v; reactive_socket_accept_op* p; ~ptr() { reset(); } static reactive_socket_accept_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_accept_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_accept_op*>(v), 1); v = 0; } } };
>
> reactive_socket_accept_op(socket_type socket,
> socket_ops::state_type state, Socket& peer, const Protocol& protocol,
> typename Protocol::endpoint* peer_endpoint, Handler& handler)
> : reactive_socket_accept_op_base<Socket, Protocol>(socket, state, peer,
> protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
>
> if (owner)
> o->do_assign();
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(o->handler_, o->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>
>
>template <typename Protocol, typename Handler>
>class reactive_socket_move_accept_op :
> private Protocol::socket,
> public reactive_socket_accept_op_base<typename Protocol::socket, Protocol>
>{
>public:
> struct ptr { Handler* h; reactive_socket_move_accept_op* v; reactive_socket_move_accept_op* p; ~ptr() { reset(); } static reactive_socket_move_accept_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_move_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_move_accept_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_move_accept_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_move_accept_op*>(v), 1); v = 0; } } };
>
> reactive_socket_move_accept_op(io_context& ioc, socket_type socket,
> socket_ops::state_type state, const Protocol& protocol,
> typename Protocol::endpoint* peer_endpoint, Handler& handler)
> : Protocol::socket(ioc),
> reactive_socket_accept_op_base<typename Protocol::socket, Protocol>(
> socket, state, *this, protocol, peer_endpoint,
> &reactive_socket_move_accept_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_move_accept_op* o(
> static_cast<reactive_socket_move_accept_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
>
> if (owner)
> o->do_assign();
>
> (void)0;
>
>
>
>
>
>
>
> detail::move_binder2<Handler,
> boost::system::error_code, typename Protocol::socket>
> handler(0, static_cast<Handler&&>(o->handler_), o->ec_,
> static_cast<typename Protocol::socket&&>(*o));
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 218 "/usr/include/boost/asio/detail/reactive_socket_accept_op.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactive_socket_connect_op_base : public reactor_op
>{
>public:
> reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
> : reactor_op(&reactive_socket_connect_op_base::do_perform, complete_func),
> socket_(socket)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_connect_op_base* o(
> static_cast<reactive_socket_connect_op_base*>(base));
>
> status result = socket_ops::non_blocking_connect(
> o->socket_, o->ec_) ? done : not_done;
>
> (void)0;
>
> return result;
> }
>
>private:
> socket_type socket_;
>};
>
>template <typename Handler>
>class reactive_socket_connect_op : public reactive_socket_connect_op_base
>{
>public:
> struct ptr { Handler* h; reactive_socket_connect_op* v; reactive_socket_connect_op* p; ~ptr() { reset(); } static reactive_socket_connect_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_connect_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_connect_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_connect_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_connect_op*>(v), 1); v = 0; } } };
>
> reactive_socket_connect_op(socket_type socket, Handler& handler)
> : reactive_socket_connect_op_base(socket,
> &reactive_socket_connect_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_connect_op* o
> (static_cast<reactive_socket_connect_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(o->handler_, o->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 114 "/usr/include/boost/asio/detail/reactive_socket_connect_op.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence, typename Endpoint>
>class reactive_socket_recvfrom_op_base : public reactor_op
>{
>public:
> reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
> const MutableBufferSequence& buffers, Endpoint& endpoint,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_recvfrom_op_base::do_perform, complete_func),
> socket_(socket),
> protocol_type_(protocol_type),
> buffers_(buffers),
> sender_endpoint_(endpoint),
> flags_(flags)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_recvfrom_op_base* o(
> static_cast<reactive_socket_recvfrom_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> std::size_t addr_len = o->sender_endpoint_.capacity();
> status result = socket_ops::non_blocking_recvfrom(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> o->sender_endpoint_.data(), &addr_len,
> o->ec_, o->bytes_transferred_) ? done : not_done;
>
> if (result && !o->ec_)
> o->sender_endpoint_.resize(addr_len);
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> socket_type socket_;
> int protocol_type_;
> MutableBufferSequence buffers_;
> Endpoint& sender_endpoint_;
> socket_base::message_flags flags_;
>};
>
>template <typename MutableBufferSequence, typename Endpoint, typename Handler>
>class reactive_socket_recvfrom_op :
> public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
>{
>public:
> struct ptr { Handler* h; reactive_socket_recvfrom_op* v; reactive_socket_recvfrom_op* p; ~ptr() { reset(); } static reactive_socket_recvfrom_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvfrom_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_recvfrom_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvfrom_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_recvfrom_op*>(v), 1); v = 0; } } };
>
> reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
> const MutableBufferSequence& buffers, Endpoint& endpoint,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
> socket, protocol_type, buffers, endpoint, flags,
> &reactive_socket_recvfrom_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_recvfrom_op* o(
> static_cast<reactive_socket_recvfrom_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 139 "/usr/include/boost/asio/detail/reactive_socket_recvfrom_op.hpp" 2 3 4
># 33 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename ConstBufferSequence, typename Endpoint>
>class reactive_socket_sendto_op_base : public reactor_op
>{
>public:
> reactive_socket_sendto_op_base(socket_type socket,
> const ConstBufferSequence& buffers, const Endpoint& endpoint,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_sendto_op_base::do_perform, complete_func),
> socket_(socket),
> buffers_(buffers),
> destination_(endpoint),
> flags_(flags)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_sendto_op_base* o(
> static_cast<reactive_socket_sendto_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(o->buffers_);
>
> status result = socket_ops::non_blocking_sendto(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> o->destination_.data(), o->destination_.size(),
> o->ec_, o->bytes_transferred_) ? done : not_done;
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> socket_type socket_;
> ConstBufferSequence buffers_;
> Endpoint destination_;
> socket_base::message_flags flags_;
>};
>
>template <typename ConstBufferSequence, typename Endpoint, typename Handler>
>class reactive_socket_sendto_op :
> public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
>{
>public:
> struct ptr { Handler* h; reactive_socket_sendto_op* v; reactive_socket_sendto_op* p; ~ptr() { reset(); } static reactive_socket_sendto_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_sendto_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_sendto_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_sendto_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_sendto_op*>(v), 1); v = 0; } } };
>
> reactive_socket_sendto_op(socket_type socket,
> const ConstBufferSequence& buffers, const Endpoint& endpoint,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>(socket,
> buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 131 "/usr/include/boost/asio/detail/reactive_socket_sendto_op.hpp" 2 3 4
># 34 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class reactive_socket_recv_op_base : public reactor_op
>{
>public:
> reactive_socket_recv_op_base(socket_type socket,
> socket_ops::state_type state, const MutableBufferSequence& buffers,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_recv_op_base::do_perform, complete_func),
> socket_(socket),
> state_(state),
> buffers_(buffers),
> flags_(flags)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_recv_op_base* o(
> static_cast<reactive_socket_recv_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> status result = socket_ops::non_blocking_recv(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> (o->state_ & socket_ops::stream_oriented) != 0,
> o->ec_, o->bytes_transferred_) ? done : not_done;
>
> if (result == done)
> if ((o->state_ & socket_ops::stream_oriented) != 0)
> if (o->bytes_transferred_ == 0)
> result = done_and_exhausted;
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> socket_type socket_;
> socket_ops::state_type state_;
> MutableBufferSequence buffers_;
> socket_base::message_flags flags_;
>};
>
>template <typename MutableBufferSequence, typename Handler>
>class reactive_socket_recv_op :
> public reactive_socket_recv_op_base<MutableBufferSequence>
>{
>public:
> struct ptr { Handler* h; reactive_socket_recv_op* v; reactive_socket_recv_op* p; ~ptr() { reset(); } static reactive_socket_recv_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recv_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_recv_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recv_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_recv_op*>(v), 1); v = 0; } } };
>
> reactive_socket_recv_op(socket_type socket,
> socket_ops::state_type state, const MutableBufferSequence& buffers,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_recv_op_base<MutableBufferSequence>(socket, state,
> buffers, flags, &reactive_socket_recv_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 136 "/usr/include/boost/asio/detail/reactive_socket_recv_op.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class reactive_socket_recvmsg_op_base : public reactor_op
>{
>public:
> reactive_socket_recvmsg_op_base(socket_type socket,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, func_type complete_func)
> : reactor_op(&reactive_socket_recvmsg_op_base::do_perform, complete_func),
> socket_(socket),
> buffers_(buffers),
> in_flags_(in_flags),
> out_flags_(out_flags)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_recvmsg_op_base* o(
> static_cast<reactive_socket_recvmsg_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> status result = socket_ops::non_blocking_recvmsg(o->socket_,
> bufs.buffers(), bufs.count(),
> o->in_flags_, o->out_flags_,
> o->ec_, o->bytes_transferred_) ? done : not_done;
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> socket_type socket_;
> MutableBufferSequence buffers_;
> socket_base::message_flags in_flags_;
> socket_base::message_flags& out_flags_;
>};
>
>template <typename MutableBufferSequence, typename Handler>
>class reactive_socket_recvmsg_op :
> public reactive_socket_recvmsg_op_base<MutableBufferSequence>
>{
>public:
> struct ptr { Handler* h; reactive_socket_recvmsg_op* v; reactive_socket_recvmsg_op* p; ~ptr() { reset(); } static reactive_socket_recvmsg_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvmsg_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_recvmsg_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_recvmsg_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_recvmsg_op*>(v), 1); v = 0; } } };
>
> reactive_socket_recvmsg_op(socket_type socket,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, Handler& handler)
> : reactive_socket_recvmsg_op_base<MutableBufferSequence>(socket, buffers,
> in_flags, out_flags, &reactive_socket_recvmsg_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_recvmsg_op* o(
> static_cast<reactive_socket_recvmsg_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 133 "/usr/include/boost/asio/detail/reactive_socket_recvmsg_op.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename ConstBufferSequence>
>class reactive_socket_send_op_base : public reactor_op
>{
>public:
> reactive_socket_send_op_base(socket_type socket,
> socket_ops::state_type state, const ConstBufferSequence& buffers,
> socket_base::message_flags flags, func_type complete_func)
> : reactor_op(&reactive_socket_send_op_base::do_perform, complete_func),
> socket_(socket),
> state_(state),
> buffers_(buffers),
> flags_(flags)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> reactive_socket_send_op_base* o(
> static_cast<reactive_socket_send_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(o->buffers_);
>
> status result = socket_ops::non_blocking_send(o->socket_,
> bufs.buffers(), bufs.count(), o->flags_,
> o->ec_, o->bytes_transferred_) ? done : not_done;
>
> if (result == done)
> if ((o->state_ & socket_ops::stream_oriented) != 0)
> if (o->bytes_transferred_ < bufs.total_size())
> result = done_and_exhausted;
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> socket_type socket_;
> socket_ops::state_type state_;
> ConstBufferSequence buffers_;
> socket_base::message_flags flags_;
>};
>
>template <typename ConstBufferSequence, typename Handler>
>class reactive_socket_send_op :
> public reactive_socket_send_op_base<ConstBufferSequence>
>{
>public:
> struct ptr { Handler* h; reactive_socket_send_op* v; reactive_socket_send_op* p; ~ptr() { reset(); } static reactive_socket_send_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_send_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_socket_send_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_socket_send_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_socket_send_op*>(v), 1); v = 0; } } };
>
> reactive_socket_send_op(socket_type socket,
> socket_ops::state_type state, const ConstBufferSequence& buffers,
> socket_base::message_flags flags, Handler& handler)
> : reactive_socket_send_op_base<ConstBufferSequence>(socket,
> state, buffers, flags, &reactive_socket_send_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 135 "/usr/include/boost/asio/detail/reactive_socket_send_op.hpp" 2 3 4
># 33 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_wait_op.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/reactive_wait_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/reactive_wait_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class reactive_wait_op : public reactor_op
>{
>public:
> struct ptr { Handler* h; reactive_wait_op* v; reactive_wait_op* p; ~ptr() { reset(); } static reactive_wait_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_wait_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~reactive_wait_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<reactive_wait_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<reactive_wait_op*>(v), 1); v = 0; } } };
>
> reactive_wait_op(Handler& handler)
> : reactor_op(&reactive_wait_op::do_perform,
> &reactive_wait_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static status do_perform(reactor_op*)
> {
> return done;
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> reactive_wait_op* o(static_cast<reactive_wait_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(o->handler_, o->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 91 "/usr/include/boost/asio/detail/reactive_wait_op.hpp" 2 3 4
># 34 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 41 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactive_socket_service_base
>{
>public:
>
> typedef socket_type native_handle_type;
>
>
> struct base_implementation_type
> {
>
> socket_type socket_;
>
>
> socket_ops::state_type state_;
>
>
> reactor::per_descriptor_data reactor_data_;
> };
>
>
> inline reactive_socket_service_base(
> boost::asio::io_context& io_context);
>
>
> inline void base_shutdown();
>
>
> inline void construct(base_implementation_type& impl);
>
>
> inline void base_move_construct(base_implementation_type& impl,
> base_implementation_type& other_impl);
>
>
> inline void base_move_assign(base_implementation_type& impl,
> reactive_socket_service_base& other_service,
> base_implementation_type& other_impl);
>
>
> inline void destroy(base_implementation_type& impl);
>
>
> bool is_open(const base_implementation_type& impl) const
> {
> return impl.socket_ != invalid_socket;
> }
>
>
> inline boost::system::error_code close(
> base_implementation_type& impl, boost::system::error_code& ec);
>
>
> inline socket_type release(
> base_implementation_type& impl, boost::system::error_code& ec);
>
>
> native_handle_type native_handle(base_implementation_type& impl)
> {
> return impl.socket_;
> }
>
>
> inline boost::system::error_code cancel(
> base_implementation_type& impl, boost::system::error_code& ec);
>
>
> bool at_mark(const base_implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return socket_ops::sockatmark(impl.socket_, ec);
> }
>
>
> std::size_t available(const base_implementation_type& impl,
> boost::system::error_code& ec) const
> {
> return socket_ops::available(impl.socket_, ec);
> }
>
>
> boost::system::error_code listen(base_implementation_type& impl,
> int backlog, boost::system::error_code& ec)
> {
> socket_ops::listen(impl.socket_, backlog, ec);
> return ec;
> }
>
>
> template <typename IO_Control_Command>
> boost::system::error_code io_control(base_implementation_type& impl,
> IO_Control_Command& command, boost::system::error_code& ec)
> {
> socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
> static_cast<ioctl_arg_type*>(command.data()), ec);
> return ec;
> }
>
>
> bool non_blocking(const base_implementation_type& impl) const
> {
> return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
> }
>
>
> boost::system::error_code non_blocking(base_implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
> return ec;
> }
>
>
> bool native_non_blocking(const base_implementation_type& impl) const
> {
> return (impl.state_ & socket_ops::internal_non_blocking) != 0;
> }
>
>
> boost::system::error_code native_non_blocking(base_implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
> return ec;
> }
>
>
>
> boost::system::error_code wait(base_implementation_type& impl,
> socket_base::wait_type w, boost::system::error_code& ec)
> {
> switch (w)
> {
> case socket_base::wait_read:
> socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
> break;
> case socket_base::wait_write:
> socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
> break;
> case socket_base::wait_error:
> socket_ops::poll_error(impl.socket_, impl.state_, -1, ec);
> break;
> default:
> ec = boost::asio::error::invalid_argument;
> break;
> }
>
> return ec;
> }
>
>
>
> template <typename Handler>
> void async_wait(base_implementation_type& impl,
> socket_base::wait_type w, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_wait_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> int op_type;
> switch (w)
> {
> case socket_base::wait_read:
> op_type = reactor::read_op;
> break;
> case socket_base::wait_write:
> op_type = reactor::write_op;
> break;
> case socket_base::wait_error:
> op_type = reactor::except_op;
> break;
> default:
> p.p->ec_ = boost::asio::error::invalid_argument;
> reactor_.post_immediate_completion(p.p, is_continuation);
> p.v = p.p = 0;
> return;
> }
>
> start_op(impl, op_type, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename ConstBufferSequence>
> size_t send(base_implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(buffers);
>
> return socket_ops::sync_send(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
> }
>
>
> size_t send(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags, boost::system::error_code& ec)
> {
>
> socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
>
> return 0;
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_send(base_implementation_type& impl,
> const ConstBufferSequence& buffers,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, true,
> ((impl.state_ & socket_ops::stream_oriented)
> && buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence>::all_empty(buffers)));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_send(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename MutableBufferSequence>
> size_t receive(base_implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> return socket_ops::sync_recv(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
> }
>
>
> size_t receive(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags, boost::system::error_code& ec)
> {
>
> socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
>
> return 0;
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_receive(base_implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
>
> (void)0
> ;
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation,
> (flags & socket_base::message_out_of_band) == 0,
> ((impl.state_ & socket_ops::stream_oriented)
> && buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence>::all_empty(buffers)));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_receive(base_implementation_type& impl, const null_buffers&,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
>
> template <typename MutableBufferSequence>
> size_t receive_with_flags(base_implementation_type& impl,
> const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
> }
>
>
> size_t receive_with_flags(base_implementation_type& impl,
> const null_buffers&, socket_base::message_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
>
> socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
>
>
>
> out_flags = 0;
>
> return 0;
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_receive_with_flags(base_implementation_type& impl,
> const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler);
>
> (void)0
> ;
>
> start_op(impl,
> (in_flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation,
> (in_flags & socket_base::message_out_of_band) == 0, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_receive_with_flags(base_implementation_type& impl,
> const null_buffers&, socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
>
>
> out_flags = 0;
>
> start_op(impl,
> (in_flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>protected:
>
> inline boost::system::error_code do_open(
> base_implementation_type& impl, int af,
> int type, int protocol, boost::system::error_code& ec);
>
>
> inline boost::system::error_code do_assign(
> base_implementation_type& impl, int type,
> const native_handle_type& native_socket, boost::system::error_code& ec);
>
>
> inline void start_op(base_implementation_type& impl, int op_type,
> reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
>
>
> inline void start_accept_op(base_implementation_type& impl,
> reactor_op* op, bool is_continuation, bool peer_is_open);
>
>
> inline void start_connect_op(base_implementation_type& impl,
> reactor_op* op, bool is_continuation,
> const socket_addr_type* addr, size_t addrlen);
>
>
> io_context& io_context_;
>
>
> reactor& reactor_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 505 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>reactive_socket_service_base::reactive_socket_service_base(
> boost::asio::io_context& io_context)
> : io_context_(io_context),
> reactor_(use_service<reactor>(io_context))
>{
> reactor_.init_task();
>}
>
>void reactive_socket_service_base::base_shutdown()
>{
>}
>
>void reactive_socket_service_base::construct(
> reactive_socket_service_base::base_implementation_type& impl)
>{
> impl.socket_ = invalid_socket;
> impl.state_ = 0;
>}
>
>void reactive_socket_service_base::base_move_construct(
> reactive_socket_service_base::base_implementation_type& impl,
> reactive_socket_service_base::base_implementation_type& other_impl)
>{
> impl.socket_ = other_impl.socket_;
> other_impl.socket_ = invalid_socket;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> reactor_.move_descriptor(impl.socket_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_socket_service_base::base_move_assign(
> reactive_socket_service_base::base_implementation_type& impl,
> reactive_socket_service_base& other_service,
> reactive_socket_service_base::base_implementation_type& other_impl)
>{
> destroy(impl);
>
> impl.socket_ = other_impl.socket_;
> other_impl.socket_ = invalid_socket;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> other_service.reactor_.move_descriptor(impl.socket_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_socket_service_base::destroy(
> reactive_socket_service_base::base_implementation_type& impl)
>{
> if (impl.socket_ != invalid_socket)
> {
> (void)0
> ;
>
> reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
> (impl.state_ & socket_ops::possible_dup) == 0);
>
> boost::system::error_code ignored_ec;
> socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
>
> reactor_.cleanup_descriptor_data(impl.reactor_data_);
> }
>}
>
>boost::system::error_code reactive_socket_service_base::close(
> reactive_socket_service_base::base_implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> (void)0
> ;
>
> reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
> (impl.state_ & socket_ops::possible_dup) == 0);
>
> socket_ops::close(impl.socket_, impl.state_, false, ec);
>
> reactor_.cleanup_descriptor_data(impl.reactor_data_);
> }
> else
> {
> ec = boost::system::error_code();
> }
># 128 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 3 4
> construct(impl);
>
> return ec;
>}
>
>socket_type reactive_socket_service_base::release(
> reactive_socket_service_base::base_implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (!is_open(impl))
> {
> ec = boost::asio::error::bad_descriptor;
> return invalid_socket;
> }
>
> (void)0
> ;
>
> reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, false);
> reactor_.cleanup_descriptor_data(impl.reactor_data_);
> socket_type sock = impl.socket_;
> construct(impl);
> ec = boost::system::error_code();
> return sock;
>}
>
>boost::system::error_code reactive_socket_service_base::cancel(
> reactive_socket_service_base::base_implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (!is_open(impl))
> {
> ec = boost::asio::error::bad_descriptor;
> return ec;
> }
>
> (void)0
> ;
>
> reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code reactive_socket_service_base::do_open(
> reactive_socket_service_base::base_implementation_type& impl,
> int af, int type, int protocol, boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> socket_holder sock(socket_ops::socket(af, type, protocol, ec));
> if (sock.get() == invalid_socket)
> return ec;
>
> if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_))
> {
> ec = boost::system::error_code(err,
> boost::asio::error::get_system_category());
> return ec;
> }
>
> impl.socket_ = sock.release();
> switch (type)
> {
> case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
> case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
> default: impl.state_ = 0; break;
> }
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code reactive_socket_service_base::do_assign(
> reactive_socket_service_base::base_implementation_type& impl, int type,
> const reactive_socket_service_base::native_handle_type& native_socket,
> boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> if (int err = reactor_.register_descriptor(
> native_socket, impl.reactor_data_))
> {
> ec = boost::system::error_code(err,
> boost::asio::error::get_system_category());
> return ec;
> }
>
> impl.socket_ = native_socket;
> switch (type)
> {
> case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
> case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
> default: impl.state_ = 0; break;
> }
> impl.state_ |= socket_ops::possible_dup;
> ec = boost::system::error_code();
> return ec;
>}
>
>void reactive_socket_service_base::start_op(
> reactive_socket_service_base::base_implementation_type& impl,
> int op_type, reactor_op* op, bool is_continuation,
> bool is_non_blocking, bool noop)
>{
> if (!noop)
> {
> if ((impl.state_ & socket_ops::non_blocking)
> || socket_ops::set_internal_non_blocking(
> impl.socket_, impl.state_, true, op->ec_))
> {
> reactor_.start_op(op_type, impl.socket_,
> impl.reactor_data_, op, is_continuation, is_non_blocking);
> return;
> }
> }
>
> reactor_.post_immediate_completion(op, is_continuation);
>}
>
>void reactive_socket_service_base::start_accept_op(
> reactive_socket_service_base::base_implementation_type& impl,
> reactor_op* op, bool is_continuation, bool peer_is_open)
>{
> if (!peer_is_open)
> start_op(impl, reactor::read_op, op, is_continuation, true, false);
> else
> {
> op->ec_ = boost::asio::error::already_open;
> reactor_.post_immediate_completion(op, is_continuation);
> }
>}
>
>void reactive_socket_service_base::start_connect_op(
> reactive_socket_service_base::base_implementation_type& impl,
> reactor_op* op, bool is_continuation,
> const socket_addr_type* addr, size_t addrlen)
>{
> if ((impl.state_ & socket_ops::non_blocking)
> || socket_ops::set_internal_non_blocking(
> impl.socket_, impl.state_, true, op->ec_))
> {
> if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
> {
> if (op->ec_ == boost::asio::error::in_progress
> || op->ec_ == boost::asio::error::would_block)
> {
> op->ec_ = boost::system::error_code();
> reactor_.start_op(reactor::connect_op, impl.socket_,
> impl.reactor_data_, op, is_continuation, false);
> return;
> }
> }
> }
>
> reactor_.post_immediate_completion(op, is_continuation);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 298 "/usr/include/boost/asio/detail/impl/reactive_socket_service_base.ipp" 2 3 4
># 508 "/usr/include/boost/asio/detail/reactive_socket_service_base.hpp" 2 3 4
># 35 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 42 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol>
>class reactive_socket_service :
> public service_base<reactive_socket_service<Protocol> >,
> public reactive_socket_service_base
>{
>public:
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef socket_type native_handle_type;
>
>
> struct implementation_type :
> reactive_socket_service_base::base_implementation_type
> {
>
> implementation_type()
> : protocol_(endpoint_type().protocol())
> {
> }
>
>
> protocol_type protocol_;
> };
>
>
> reactive_socket_service(boost::asio::io_context& io_context)
> : service_base<reactive_socket_service<Protocol> >(io_context),
> reactive_socket_service_base(io_context)
> {
> }
>
>
> void shutdown()
> {
> this->base_shutdown();
> }
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> this->base_move_construct(impl, other_impl);
>
> impl.protocol_ = other_impl.protocol_;
> other_impl.protocol_ = endpoint_type().protocol();
> }
>
>
> void move_assign(implementation_type& impl,
> reactive_socket_service_base& other_service,
> implementation_type& other_impl)
> {
> this->base_move_assign(impl, other_service, other_impl);
>
> impl.protocol_ = other_impl.protocol_;
> other_impl.protocol_ = endpoint_type().protocol();
> }
>
>
> template <typename Protocol1>
> void converting_move_construct(implementation_type& impl,
> reactive_socket_service<Protocol1>&,
> typename reactive_socket_service<
> Protocol1>::implementation_type& other_impl)
> {
> this->base_move_construct(impl, other_impl);
>
> impl.protocol_ = protocol_type(other_impl.protocol_);
> other_impl.protocol_ = typename Protocol1::endpoint().protocol();
> }
>
>
> boost::system::error_code open(implementation_type& impl,
> const protocol_type& protocol, boost::system::error_code& ec)
> {
> if (!do_open(impl, protocol.family(),
> protocol.type(), protocol.protocol(), ec))
> impl.protocol_ = protocol;
> return ec;
> }
>
>
> boost::system::error_code assign(implementation_type& impl,
> const protocol_type& protocol, const native_handle_type& native_socket,
> boost::system::error_code& ec)
> {
> if (!do_assign(impl, protocol.type(), native_socket, ec))
> impl.protocol_ = protocol;
> return ec;
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return impl.socket_;
> }
>
>
> boost::system::error_code bind(implementation_type& impl,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
> return ec;
> }
>
>
> template <typename Option>
> boost::system::error_code set_option(implementation_type& impl,
> const Option& option, boost::system::error_code& ec)
> {
> socket_ops::setsockopt(impl.socket_, impl.state_,
> option.level(impl.protocol_), option.name(impl.protocol_),
> option.data(impl.protocol_), option.size(impl.protocol_), ec);
> return ec;
> }
>
>
> template <typename Option>
> boost::system::error_code get_option(const implementation_type& impl,
> Option& option, boost::system::error_code& ec) const
> {
> std::size_t size = option.size(impl.protocol_);
> socket_ops::getsockopt(impl.socket_, impl.state_,
> option.level(impl.protocol_), option.name(impl.protocol_),
> option.data(impl.protocol_), &size, ec);
> if (!ec)
> option.resize(impl.protocol_, size);
> return ec;
> }
>
>
> endpoint_type local_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> endpoint_type endpoint;
> std::size_t addr_len = endpoint.capacity();
> if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec))
> return endpoint_type();
> endpoint.resize(addr_len);
> return endpoint;
> }
>
>
> endpoint_type remote_endpoint(const implementation_type& impl,
> boost::system::error_code& ec) const
> {
> endpoint_type endpoint;
> std::size_t addr_len = endpoint.capacity();
> if (socket_ops::getpeername(impl.socket_,
> endpoint.data(), &addr_len, false, ec))
> return endpoint_type();
> endpoint.resize(addr_len);
> return endpoint;
> }
>
>
> boost::system::error_code shutdown(base_implementation_type& impl,
> socket_base::shutdown_type what, boost::system::error_code& ec)
> {
> socket_ops::shutdown(impl.socket_, what, ec);
> return ec;
> }
>
>
>
> template <typename ConstBufferSequence>
> size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(buffers);
>
> return socket_ops::sync_sendto(impl.socket_, impl.state_,
> bufs.buffers(), bufs.count(), flags,
> destination.data(), destination.size(), ec);
> }
>
>
> size_t send_to(implementation_type& impl, const null_buffers&,
> const endpoint_type&, socket_base::message_flags,
> boost::system::error_code& ec)
> {
>
> socket_ops::poll_write(impl.socket_, impl.state_, -1, ec);
>
> return 0;
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_send_to(implementation_type& impl,
> const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_sendto_op<ConstBufferSequence,
> endpoint_type, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, true, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_send_to(implementation_type& impl, const null_buffers&,
> const endpoint_type&, socket_base::message_flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
>
> template <typename MutableBufferSequence>
> size_t receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> std::size_t addr_len = sender_endpoint.capacity();
> std::size_t bytes_recvd = socket_ops::sync_recvfrom(
> impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
> flags, sender_endpoint.data(), &addr_len, ec);
>
> if (!ec)
> sender_endpoint.resize(addr_len);
>
> return bytes_recvd;
> }
>
>
> size_t receive_from(implementation_type& impl, const null_buffers&,
> endpoint_type& sender_endpoint, socket_base::message_flags,
> boost::system::error_code& ec)
> {
>
> socket_ops::poll_read(impl.socket_, impl.state_, -1, ec);
>
>
> sender_endpoint = endpoint_type();
>
> return 0;
> }
>
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_receive_from(implementation_type& impl,
> const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_recvfrom_op<MutableBufferSequence,
> endpoint_type, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> int protocol = impl.protocol_.type();
> p.p = new (p.v) op(impl.socket_, protocol,
> buffers, sender_endpoint, flags, handler);
>
> (void)0
> ;
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, true, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_receive_from(implementation_type& impl,
> const null_buffers&, endpoint_type& sender_endpoint,
> socket_base::message_flags flags, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
>
> sender_endpoint = endpoint_type();
>
> start_op(impl,
> (flags & socket_base::message_out_of_band)
> ? reactor::except_op : reactor::read_op,
> p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename Socket>
> boost::system::error_code accept(implementation_type& impl,
> Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
> {
>
> if (peer.is_open())
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
> socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
> impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
> peer_endpoint ? &addr_len : 0, ec));
>
>
> if (new_socket.get() != invalid_socket)
> {
> if (peer_endpoint)
> peer_endpoint->resize(addr_len);
> peer.assign(impl.protocol_, new_socket.get(), ec);
> if (!ec)
> new_socket.release();
> }
>
> return ec;
> }
>
>
>
> typename Protocol::socket accept(implementation_type& impl,
> io_context* peer_io_context, endpoint_type* peer_endpoint,
> boost::system::error_code& ec)
> {
> typename Protocol::socket peer(
> peer_io_context ? *peer_io_context : io_context_);
>
> std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
> socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
> impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
> peer_endpoint ? &addr_len : 0, ec));
>
>
> if (new_socket.get() != invalid_socket)
> {
> if (peer_endpoint)
> peer_endpoint->resize(addr_len);
> peer.assign(impl.protocol_, new_socket.get(), ec);
> if (!ec)
> new_socket.release();
> }
>
> return peer;
> }
>
>
>
>
> template <typename Socket, typename Handler>
> void async_accept(implementation_type& impl, Socket& peer,
> endpoint_type* peer_endpoint, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_accept_op<Socket, Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.socket_, impl.state_, peer,
> impl.protocol_, peer_endpoint, handler);
>
> (void)0
> ;
>
> start_accept_op(impl, p.p, is_continuation, peer.is_open());
> p.v = p.p = 0;
> }
>
>
>
>
> template <typename Handler>
> void async_accept(implementation_type& impl,
> boost::asio::io_context* peer_io_context,
> endpoint_type* peer_endpoint, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_move_accept_op<Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(peer_io_context ? *peer_io_context : io_context_,
> impl.socket_, impl.state_, impl.protocol_, peer_endpoint, handler);
>
> (void)0
> ;
>
> start_accept_op(impl, p.p, is_continuation, false);
> p.v = p.p = 0;
> }
>
>
>
> boost::system::error_code connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> socket_ops::sync_connect(impl.socket_,
> peer_endpoint.data(), peer_endpoint.size(), ec);
> return ec;
> }
>
>
> template <typename Handler>
> void async_connect(implementation_type& impl,
> const endpoint_type& peer_endpoint, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_socket_connect_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.socket_, handler);
>
> (void)0
> ;
>
> start_connect_op(impl, p.p, is_continuation,
> peer_endpoint.data(), peer_endpoint.size());
> p.v = p.p = 0;
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 525 "/usr/include/boost/asio/detail/reactive_socket_service.hpp" 2 3 4
># 41 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 46 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 59 "/usr/include/boost/asio/basic_socket.hpp" 3 4
>template <typename Protocol >
>class basic_socket
> : protected basic_io_object<detail::reactive_socket_service<Protocol> >,
> public socket_base
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
>
>
>
> typedef typename detail::reactive_socket_service<Protocol>::native_handle_type native_handle_type;
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
>
> typedef basic_socket<Protocol > lowest_layer_type;
># 93 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> explicit basic_socket(boost::asio::io_context& io_context)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> }
># 109 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 133 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(boost::asio::io_context& io_context,
> const endpoint_type& endpoint)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> boost::system::error_code ec;
> const protocol_type protocol = endpoint.protocol();
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> }
># 158 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_socket, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 179 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket(basic_socket&& other)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(std::move(other))
> {
> }
># 194 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> basic_socket& operator=(basic_socket&& other)
> {
> basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(other));
> return *this;
> }
>
>
> template <typename Protocol1 >
> friend class basic_socket;
># 214 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename Protocol1 >
> basic_socket(basic_socket<Protocol1 >&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(
> other.get_service(), other.get_implementation())
> {
> }
># 232 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename Protocol1 >
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_socket>::type& operator=(
> basic_socket<Protocol1 >&& other)
> {
> basic_socket tmp(std::move(other));
> basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(tmp));
> return *this;
> }
># 256 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_context();
> }
># 270 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<detail::reactive_socket_service<Protocol> >::get_executor();
> }
># 293 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return *this;
> }
># 307 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return *this;
> }
># 327 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void open(const protocol_type& protocol = protocol_type())
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 353 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code open(const protocol_type& protocol,
> boost::system::error_code& ec)
> {
> this->get_service().open(this->get_implementation(), protocol, ec);
> return ec;
> }
># 370 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void assign(const protocol_type& protocol,
> const native_handle_type& native_socket)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_socket, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 389 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code assign(const protocol_type& protocol,
> const native_handle_type& native_socket, boost::system::error_code& ec)
> {
> this->get_service().assign(this->get_implementation(),
> protocol, native_socket, ec);
> return ec;
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 415 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 446 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> this->get_service().close(this->get_implementation(), ec);
> return ec;
> }
># 471 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> native_handle_type release()
> {
> boost::system::error_code ec;
> native_handle_type s = this->get_service().release(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "release");
> return s;
> }
># 499 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> native_handle_type release(boost::system::error_code& ec)
> {
> return this->get_service().release(this->get_implementation(), ec);
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 556 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 604 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> this->get_service().cancel(this->get_implementation(), ec);
> return ec;
> }
># 620 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool at_mark() const
> {
> boost::system::error_code ec;
> bool b = this->get_service().at_mark(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "at_mark");
> return b;
> }
># 638 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool at_mark(boost::system::error_code& ec) const
> {
> return this->get_service().at_mark(this->get_implementation(), ec);
> }
># 653 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> std::size_t available() const
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().available(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "available");
> return s;
> }
># 672 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> std::size_t available(boost::system::error_code& ec) const
> {
> return this->get_service().available(this->get_implementation(), ec);
> }
># 695 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void bind(const endpoint_type& endpoint)
> {
> boost::system::error_code ec;
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> }
># 725 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code bind(const endpoint_type& endpoint,
> boost::system::error_code& ec)
> {
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> return ec;
> }
># 755 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void connect(const endpoint_type& peer_endpoint)
> {
> boost::system::error_code ec;
> if (!is_open())
> {
> this->get_service().open(this->get_implementation(),
> peer_endpoint.protocol(), ec);
> boost::asio::detail::throw_error(ec, "connect");
> }
> this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
> boost::asio::detail::throw_error(ec, "connect");
> }
># 796 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code connect(const endpoint_type& peer_endpoint,
> boost::system::error_code& ec)
> {
> if (!is_open())
> {
> this->get_service().open(this->get_implementation(),
> peer_endpoint.protocol(), ec);
> if (ec)
> {
> return ec;
> }
> }
>
> this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
> return ec;
> }
># 854 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename ConnectHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ConnectHandler>::type, void (boost::system::error_code)>::return_type
>
> async_connect(const endpoint_type& peer_endpoint,
> ConnectHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ConnectHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
> if (!is_open())
> {
> boost::system::error_code ec;
> const protocol_type protocol = peer_endpoint.protocol();
> this->get_service().open(this->get_implementation(), protocol, ec);
> if (ec)
> {
> async_completion<ConnectHandler,
> void (boost::system::error_code)> init(handler);
>
> boost::asio::post(this->get_executor(),
> boost::asio::detail::bind_handler(
> static_cast<typename ::boost::asio::async_result< typename ::boost::asio::decay<ConnectHandler>::type, void (boost::system::error_code)>::completion_handler_type&&>
> (
> init.completion_handler), ec));
>
> return init.result.get();
> }
> }
>
>
>
>
>
> async_completion<ConnectHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_connect(
> this->get_implementation(), peer_endpoint, init.completion_handler);
>
> return init.result.get();
>
> }
># 932 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename SettableSocketOption>
> void set_option(const SettableSocketOption& option)
> {
> boost::system::error_code ec;
> this->get_service().set_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
># 979 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename SettableSocketOption>
> boost::system::error_code set_option(const SettableSocketOption& option,
> boost::system::error_code& ec)
> {
> this->get_service().set_option(this->get_implementation(), option, ec);
> return ec;
> }
># 1022 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename GettableSocketOption>
> void get_option(GettableSocketOption& option) const
> {
> boost::system::error_code ec;
> this->get_service().get_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "get_option");
> }
># 1070 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename GettableSocketOption>
> boost::system::error_code get_option(GettableSocketOption& option,
> boost::system::error_code& ec) const
> {
> this->get_service().get_option(this->get_implementation(), option, ec);
> return ec;
> }
># 1100 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename IoControlCommand>
> void io_control(IoControlCommand& command)
> {
> boost::system::error_code ec;
> this->get_service().io_control(this->get_implementation(), command, ec);
> boost::asio::detail::throw_error(ec, "io_control");
> }
># 1135 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename IoControlCommand>
> boost::system::error_code io_control(IoControlCommand& command,
> boost::system::error_code& ec)
> {
> this->get_service().io_control(this->get_implementation(), command, ec);
> return ec;
> }
># 1154 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool non_blocking() const
> {
> return this->get_service().non_blocking(this->get_implementation());
> }
># 1172 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "non_blocking");
> }
># 1192 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> return ec;
> }
># 1283 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> bool native_non_blocking() const
> {
> return this->get_service().native_non_blocking(this->get_implementation());
> }
># 1373 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void native_non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "native_non_blocking");
> }
># 1466 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code native_non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> return ec;
> }
># 1489 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type local_endpoint() const
> {
> boost::system::error_code ec;
> endpoint_type ep = this->get_service().local_endpoint(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "local_endpoint");
> return ep;
> }
># 1519 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type local_endpoint(boost::system::error_code& ec) const
> {
> return this->get_service().local_endpoint(this->get_implementation(), ec);
> }
># 1539 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type remote_endpoint() const
> {
> boost::system::error_code ec;
> endpoint_type ep = this->get_service().remote_endpoint(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "remote_endpoint");
> return ep;
> }
># 1569 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> endpoint_type remote_endpoint(boost::system::error_code& ec) const
> {
> return this->get_service().remote_endpoint(this->get_implementation(), ec);
> }
># 1591 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void shutdown(shutdown_type what)
> {
> boost::system::error_code ec;
> this->get_service().shutdown(this->get_implementation(), what, ec);
> boost::asio::detail::throw_error(ec, "shutdown");
> }
># 1620 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code shutdown(shutdown_type what,
> boost::system::error_code& ec)
> {
> this->get_service().shutdown(this->get_implementation(), what, ec);
> return ec;
> }
># 1643 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> void wait(wait_type w)
> {
> boost::system::error_code ec;
> this->get_service().wait(this->get_implementation(), w, ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 1669 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> boost::system::error_code wait(wait_type w, boost::system::error_code& ec)
> {
> this->get_service().wait(this->get_implementation(), w, ec);
> return ec;
> }
># 1711 "/usr/include/boost/asio/basic_socket.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type
>
> async_wait(wait_type w, WaitHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WaitHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_wait(this->get_implementation(),
> w, init.completion_handler);
>
> return init.result.get();
>
> }
>
>protected:
>
>
>
>
>
> ~basic_socket()
> {
> }
>
>private:
>
> basic_socket(const basic_socket&) = delete;
> basic_socket& operator=(const basic_socket&) = delete;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1754 "/usr/include/boost/asio/basic_socket.hpp" 2 3 4
># 21 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
># 30 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 44 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
>template <typename Protocol
> >
>class basic_datagram_socket
> : public basic_socket<Protocol >
>{
>public:
>
>
>
>
> typedef typename basic_socket<
> Protocol >::native_handle_type native_handle_type;
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 73 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> explicit basic_datagram_socket(boost::asio::io_context& io_context)
> : basic_socket<Protocol >(io_context)
> {
> }
># 90 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol)
> : basic_socket<Protocol >(io_context, protocol)
> {
> }
># 112 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(boost::asio::io_context& io_context,
> const endpoint_type& endpoint)
> : basic_socket<Protocol >(io_context, endpoint)
> {
> }
># 133 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol >(
> io_context, protocol, native_socket)
> {
> }
># 151 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket(basic_datagram_socket&& other)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 167 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> basic_datagram_socket& operator=(basic_datagram_socket&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
># 184 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename Protocol1 >
> basic_datagram_socket(
> basic_datagram_socket<Protocol1 >&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 204 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename Protocol1 >
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_datagram_socket>::type& operator=(
> basic_datagram_socket<Protocol1 >&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
>
>
>
>
>
>
>
> ~basic_datagram_socket()
> {
> }
># 245 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 272 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 300 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 343 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 395 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(this->get_implementation(),
> buffers, flags, init.completion_handler);
>
> return init.result.get();
>
> }
># 445 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, 0, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 472 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, flags, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 499 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().send_to(this->get_implementation(),
> buffers, destination, flags, ec);
> }
># 545 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send_to(
> this->get_implementation(), buffers, destination, 0,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 599 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send_to(
> this->get_implementation(), buffers, destination, flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 650 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 678 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 707 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> }
># 751 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 803 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, flags, init.completion_handler);
>
> return init.result.get();
>
> }
># 854 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 881 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 908 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().receive_from(this->get_implementation(),
> buffers, sender_endpoint, flags, ec);
> }
># 953 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 1009 "/usr/include/boost/asio/basic_datagram_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1041 "/usr/include/boost/asio/basic_datagram_socket.hpp" 2 3 4
># 24 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_deadline_timer.hpp" 1 3 4
># 28 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
># 1 "/usr/include/boost/asio/time_traits.hpp" 1 3 4
># 23 "/usr/include/boost/asio/time_traits.hpp" 3 4
># 1 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 1 3 4
># 10 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 3 4
># 1 "/usr/include/boost/date_time/time_clock.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/time_clock.hpp" 3 4
># 1 "/usr/include/boost/date_time/c_time.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/c_time.hpp" 3 4
># 1 "/usr/include/c++/8/ctime" 1 3 4
># 39 "/usr/include/c++/8/ctime" 3 4
> 
># 40 "/usr/include/c++/8/ctime" 3
># 18 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/date_time/compiler_config.hpp" 1 3 4
># 11 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/c++/8/cstdlib" 1 3 4
># 39 "/usr/include/c++/8/cstdlib" 3 4
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 12 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 31 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/boost/date_time/locale_config.hpp" 1 3 4
># 32 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 54 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 55 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 157 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 158 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
># 22 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
># 31 "/usr/include/boost/date_time/c_time.hpp" 3 4
># 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;
> };
>
>typedef struct timezone *__restrict __timezone_ptr_t;
># 68 "/usr/include/sys/time.h" 3 4
>extern int gettimeofday (struct timeval *__restrict __tv,
> __timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>extern int settimeofday (const struct timeval *__tv,
> const struct timezone *__tz)
> throw ();
>
>
>
>
>
>extern int adjtime (const struct timeval *__delta,
> struct timeval *__olddelta) throw ();
>
>
>
>
>enum __itimer_which
> {
>
> ITIMER_REAL = 0,
>
>
> ITIMER_VIRTUAL = 1,
>
>
>
> ITIMER_PROF = 2
>
> };
>
>
>
>struct itimerval
> {
>
> struct timeval it_interval;
>
> struct timeval it_value;
> };
>
>
>
>
>
>
>typedef int __itimer_which_t;
>
>
>
>
>extern int getitimer (__itimer_which_t __which,
> struct itimerval *__value) throw ();
>
>
>
>
>extern int setitimer (__itimer_which_t __which,
> const struct itimerval *__restrict __new,
> struct itimerval *__restrict __old) throw ();
>
>
>
>
>extern int utimes (const char *__file, const struct timeval __tvp[2])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int lutimes (const char *__file, const struct timeval __tvp[2])
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
>
>
>
>
>
>
>extern int futimesat (int __fd, const char *__file,
> const struct timeval __tvp[2]) throw ();
># 186 "/usr/include/sys/time.h" 3 4
>}
># 32 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace date_time {
># 52 "/usr/include/boost/date_time/c_time.hpp" 3 4
> struct c_time {
> public:
>
>
> inline
> static std::tm* localtime(const std::time_t* t, std::tm* result)
> {
># 67 "/usr/include/boost/date_time/c_time.hpp" 3 4
> result = localtime_r(t, result);
>
> if (!result)
> boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
> return result;
> }
>
> inline
> static std::tm* gmtime(const std::time_t* t, std::tm* result)
> {
># 85 "/usr/include/boost/date_time/c_time.hpp" 3 4
> result = gmtime_r(t, result);
>
> if (!result)
> boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
> return result;
> }
># 120 "/usr/include/boost/date_time/c_time.hpp" 3 4
> };
>}}
># 17 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4
># 1 "/usr/include/boost/shared_ptr.hpp" 1 3 4
># 17 "/usr/include/boost/shared_ptr.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 1 3 4
># 23 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
># 1 "/usr/include/boost/config/no_tr1/memory.hpp" 1 3 4
># 24 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/assert.hpp" 1 3 4
># 58 "/usr/include/boost/assert.hpp" 3 4
># 1 "/usr/include/assert.h" 1 3 4
># 64 "/usr/include/assert.h" 3 4
>extern "C" {
>
>
>extern void __assert_fail (const char *__assertion, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 59 "/usr/include/boost/assert.hpp" 2 3 4
># 26 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/checked_delete.hpp" 1 3 4
># 15 "/usr/include/boost/checked_delete.hpp" 3 4
># 1 "/usr/include/boost/core/checked_delete.hpp" 1 3 4
># 24 "/usr/include/boost/core/checked_delete.hpp" 3 4
>namespace boost
>{
>
>
>
>template<class T> inline void checked_delete(T * x)
>{
>
> typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
> (void) sizeof(type_must_be_complete);
> delete x;
>}
>
>template<class T> inline void checked_array_delete(T * x)
>{
> typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
> (void) sizeof(type_must_be_complete);
> delete [] x;
>}
>
>template<class T> struct checked_deleter
>{
> typedef void result_type;
> typedef T * argument_type;
>
> void operator()(T * x) const
> {
>
> boost::checked_delete(x);
> }
>};
>
>template<class T> struct checked_array_deleter
>{
> typedef void result_type;
> typedef T * argument_type;
>
> void operator()(T * x) const
> {
> boost::checked_array_delete(x);
> }
>};
>
>}
># 16 "/usr/include/boost/checked_delete.hpp" 2 3 4
># 27 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 1 3 4
># 28 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3 4
># 27 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
>namespace boost
>{
># 46 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
>class bad_weak_ptr: public std::exception
>{
>public:
>
> virtual char const * what() const throw()
> {
> return "tr1::bad_weak_ptr";
> }
>};
># 64 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
>}
># 29 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3 4
># 21 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_has_sync.hpp" 1 3 4
># 22 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
># 48 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 1 3 4
># 18 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 3 4
># 1 "/usr/include/boost/detail/sp_typeinfo.hpp" 1 3 4
># 20 "/usr/include/boost/detail/sp_typeinfo.hpp" 3 4
># 1 "/usr/include/boost/core/typeinfo.hpp" 1 3 4
># 119 "/usr/include/boost/core/typeinfo.hpp" 3 4
># 1 "/usr/include/boost/core/demangle.hpp" 1 3 4
># 17 "/usr/include/boost/core/demangle.hpp" 3 4
> 
># 32 "/usr/include/boost/core/demangle.hpp" 3 4
># 1 "/usr/include/c++/8/cxxabi.h" 1 3 4
># 44 "/usr/include/c++/8/cxxabi.h" 3 4
> 
># 45 "/usr/include/c++/8/cxxabi.h" 3
>
>#pragma GCC visibility push(default)
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 49 "/usr/include/c++/8/cxxabi.h" 2 3
>
># 1 "/usr/include/c++/8/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 1 3
># 34 "/usr/include/c++/8/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
>namespace __cxxabiv1
>{
> extern "C"
> {
># 46 "/usr/include/c++/8/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
> __extension__ typedef int __guard __attribute__((mode (__DI__)));
>
>
> typedef void __cxa_vec_ctor_return_type;
>
>
> typedef void __cxa_cdtor_return_type;
>
>
> }
>}
># 51 "/usr/include/c++/8/cxxabi.h" 2 3
>
>
>
>
>namespace __cxxabiv1
>{
> extern "C"
> {
>
>
> typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
>
>
> void*
> __cxa_vec_new(size_t __element_count, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor);
>
> void*
> __cxa_vec_new2(size_t __element_count, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
> void (*__dealloc) (void*));
>
> void*
> __cxa_vec_new3(size_t __element_count, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
> void (*__dealloc) (void*, size_t));
>
>
> __cxa_vec_ctor_return_type
> __cxa_vec_ctor(void* __array_address, size_t __element_count,
> size_t __element_size, __cxa_cdtor_type __constructor,
> __cxa_cdtor_type __destructor);
>
> __cxa_vec_ctor_return_type
> __cxa_vec_cctor(void* __dest_array, void* __src_array,
> size_t __element_count, size_t __element_size,
> __cxa_cdtor_return_type (*__constructor) (void*, void*),
> __cxa_cdtor_type __destructor);
>
>
> void
> __cxa_vec_dtor(void* __array_address, size_t __element_count,
> size_t __element_size, __cxa_cdtor_type __destructor);
>
> void
> __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
> __cxa_cdtor_type __destructor) noexcept;
>
>
> void
> __cxa_vec_delete(void* __array_address, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __destructor);
>
> void
> __cxa_vec_delete2(void* __array_address, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __destructor,
> void (*__dealloc) (void*));
>
> void
> __cxa_vec_delete3(void* __array_address, size_t __element_size,
> size_t __padding_size, __cxa_cdtor_type __destructor,
> void (*__dealloc) (void*, size_t));
>
> int
> __cxa_guard_acquire(__guard*);
>
> void
> __cxa_guard_release(__guard*) noexcept;
>
> void
> __cxa_guard_abort(__guard*) noexcept;
>
>
> int
> __cxa_atexit(void (*)(void*), void*, void*) noexcept;
>
> int
> __cxa_finalize(void*);
>
>
> int
> __cxa_thread_atexit(void (*)(void*), void*, void *) noexcept;
>
>
> void
> __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
>
> void
> __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
>
>
> void
> __cxa_bad_cast() __attribute__((__noreturn__));
>
> void
> __cxa_bad_typeid() __attribute__((__noreturn__));
>
> void
> __cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
># 194 "/usr/include/c++/8/cxxabi.h" 3
> char*
> __cxa_demangle(const char* __mangled_name, char* __output_buffer,
> size_t* __length, int* __status);
>
>
> }
>}
>
>
>
>
>
>
>namespace __cxxabiv1
>{
>
> class __fundamental_type_info : public std::type_info
> {
> public:
> explicit
> __fundamental_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__fundamental_type_info();
> };
>
>
> class __array_type_info : public std::type_info
> {
> public:
> explicit
> __array_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__array_type_info();
> };
>
>
> class __function_type_info : public std::type_info
> {
> public:
> explicit
> __function_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__function_type_info();
>
> protected:
>
> virtual bool
> __is_function_p() const;
> };
>
>
> class __enum_type_info : public std::type_info
> {
> public:
> explicit
> __enum_type_info(const char* __n) : std::type_info(__n) { }
>
> virtual
> ~__enum_type_info();
> };
>
>
> class __pbase_type_info : public std::type_info
> {
> public:
> unsigned int __flags;
> const std::type_info* __pointee;
>
> explicit
> __pbase_type_info(const char* __n, int __quals,
> const std::type_info* __type)
> : std::type_info(__n), __flags(__quals), __pointee(__type)
> { }
>
> virtual
> ~__pbase_type_info();
>
>
> enum __masks
> {
> __const_mask = 0x1,
> __volatile_mask = 0x2,
> __restrict_mask = 0x4,
> __incomplete_mask = 0x8,
> __incomplete_class_mask = 0x10,
> __transaction_safe_mask = 0x20,
> __noexcept_mask = 0x40
> };
>
> protected:
> __pbase_type_info(const __pbase_type_info&);
>
> __pbase_type_info&
> operator=(const __pbase_type_info&);
>
>
> virtual bool
> __do_catch(const std::type_info* __thr_type, void** __thr_obj,
> unsigned int __outer) const;
>
> inline virtual bool
> __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
> };
>
> inline bool __pbase_type_info::
> __pointer_catch (const __pbase_type_info *thrown_type,
> void **thr_obj,
> unsigned outer) const
> {
> return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
> }
>
>
> class __pointer_type_info : public __pbase_type_info
> {
> public:
> explicit
> __pointer_type_info(const char* __n, int __quals,
> const std::type_info* __type)
> : __pbase_type_info (__n, __quals, __type) { }
>
>
> virtual
> ~__pointer_type_info();
>
> protected:
>
> virtual bool
> __is_pointer_p() const;
>
> virtual bool
> __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
> };
>
> class __class_type_info;
>
>
> class __pointer_to_member_type_info : public __pbase_type_info
> {
> public:
> __class_type_info* __context;
>
> explicit
> __pointer_to_member_type_info(const char* __n, int __quals,
> const std::type_info* __type,
> __class_type_info* __klass)
> : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
>
> virtual
> ~__pointer_to_member_type_info();
>
> protected:
> __pointer_to_member_type_info(const __pointer_to_member_type_info&);
>
> __pointer_to_member_type_info&
> operator=(const __pointer_to_member_type_info&);
>
>
> virtual bool
> __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
> };
>
>
> class __base_class_type_info
> {
> public:
> const __class_type_info* __base_type;
>
>
>
> long __offset_flags;
>
>
> enum __offset_flags_masks
> {
> __virtual_mask = 0x1,
> __public_mask = 0x2,
> __hwm_bit = 2,
> __offset_shift = 8
> };
>
>
> bool
> __is_virtual_p() const
> { return __offset_flags & __virtual_mask; }
>
> bool
> __is_public_p() const
> { return __offset_flags & __public_mask; }
>
> ptrdiff_t
> __offset() const
> {
>
>
>
> return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
> }
> };
>
>
> class __class_type_info : public std::type_info
> {
> public:
> explicit
> __class_type_info (const char *__n) : type_info(__n) { }
>
> virtual
> ~__class_type_info ();
>
>
>
>
>
>
> enum __sub_kind
> {
>
> __unknown = 0,
>
>
>
> __not_contained,
>
>
> __contained_ambig,
>
>
> __contained_virtual_mask = __base_class_type_info::__virtual_mask,
>
>
> __contained_public_mask = __base_class_type_info::__public_mask,
>
>
> __contained_mask = 1 << __base_class_type_info::__hwm_bit,
>
> __contained_private = __contained_mask,
> __contained_public = __contained_mask | __contained_public_mask
> };
>
> struct __upcast_result;
> struct __dyncast_result;
>
> protected:
>
> virtual bool
> __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
>
> virtual bool
> __do_catch(const type_info* __thr_type, void** __thr_obj,
> unsigned __outer) const;
>
> public:
>
>
> virtual bool
> __do_upcast(const __class_type_info* __dst, const void* __obj,
> __upcast_result& __restrict __result) const;
>
>
>
>
>
>
>
> inline __sub_kind
> __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __src_ptr) const;
># 477 "/usr/include/c++/8/cxxabi.h" 3
> virtual bool
> __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
> const __class_type_info* __dst_type, const void* __obj_ptr,
> const __class_type_info* __src_type, const void* __src_ptr,
> __dyncast_result& __result) const;
>
>
>
>
>
> virtual __sub_kind
> __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __src_ptr) const;
> };
>
>
> class __si_class_type_info : public __class_type_info
> {
> public:
> const __class_type_info* __base_type;
>
> explicit
> __si_class_type_info(const char *__n, const __class_type_info *__base)
> : __class_type_info(__n), __base_type(__base) { }
>
> virtual
> ~__si_class_type_info();
>
> protected:
> __si_class_type_info(const __si_class_type_info&);
>
> __si_class_type_info&
> operator=(const __si_class_type_info&);
>
>
> virtual bool
> __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
> const __class_type_info* __dst_type, const void* __obj_ptr,
> const __class_type_info* __src_type, const void* __src_ptr,
> __dyncast_result& __result) const;
>
> virtual __sub_kind
> __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __sub_ptr) const;
>
> virtual bool
> __do_upcast(const __class_type_info*__dst, const void*__obj,
> __upcast_result& __restrict __result) const;
> };
>
>
> class __vmi_class_type_info : public __class_type_info
> {
> public:
> unsigned int __flags;
> unsigned int __base_count;
>
>
>
>
> __base_class_type_info __base_info[1];
>
> explicit
> __vmi_class_type_info(const char* __n, int ___flags)
> : __class_type_info(__n), __flags(___flags), __base_count(0) { }
>
> virtual
> ~__vmi_class_type_info();
>
>
> enum __flags_masks
> {
> __non_diamond_repeat_mask = 0x1,
> __diamond_shaped_mask = 0x2,
> __flags_unknown_mask = 0x10
> };
>
> protected:
>
> virtual bool
> __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
> const __class_type_info* __dst_type, const void* __obj_ptr,
> const __class_type_info* __src_type, const void* __src_ptr,
> __dyncast_result& __result) const;
>
> virtual __sub_kind
> __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
> const __class_type_info* __src_type,
> const void* __src_ptr) const;
>
> virtual bool
> __do_upcast(const __class_type_info* __dst, const void* __obj,
> __upcast_result& __restrict __result) const;
> };
>
>
> struct __cxa_exception;
> struct __cxa_refcounted_exception;
> struct __cxa_dependent_exception;
> struct __cxa_eh_globals;
>
> extern "C"
> {
># 590 "/usr/include/c++/8/cxxabi.h" 3
> void*
> __dynamic_cast(const void* __src_ptr,
> const __class_type_info* __src_type,
> const __class_type_info* __dst_type,
> ptrdiff_t __src2dst);
># 603 "/usr/include/c++/8/cxxabi.h" 3
> __cxa_eh_globals*
> __cxa_get_globals() noexcept __attribute__ ((__const__));
>
> __cxa_eh_globals*
> __cxa_get_globals_fast() noexcept __attribute__ ((__const__));
>
>
> void
> __cxa_free_exception(void*) noexcept;
>
>
> void
> __cxa_throw(void*, std::type_info*, void ( *) (void *))
> __attribute__((__noreturn__));
>
>
> void*
> __cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__));
>
> void*
> __cxa_begin_catch(void*) noexcept;
>
> void
> __cxa_end_catch();
>
> void
> __cxa_rethrow() __attribute__((__noreturn__));
>
>
>
> std::type_info*
> __cxa_current_exception_type() noexcept __attribute__ ((__pure__));
>
>
>
>
> __cxa_dependent_exception*
> __cxa_allocate_dependent_exception() noexcept;
>
>
> void
> __cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept;
>
> }
>
>
>
> class __foreign_exception
> {
> virtual ~__foreign_exception() throw();
> virtual void __pure_dummy() = 0;
> };
>
>}
># 678 "/usr/include/c++/8/cxxabi.h" 3
>namespace abi = __cxxabiv1;
>
>namespace __gnu_cxx
>{
># 694 "/usr/include/c++/8/cxxabi.h" 3
> class recursive_init_error: public std::exception
> {
> public:
> recursive_init_error() throw() { }
> virtual ~recursive_init_error() throw ();
> };
>}
>
>
>#pragma GCC visibility pop
># 33 "/usr/include/boost/core/demangle.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/c++/8/cstdlib" 1 3 4
># 39 "/usr/include/c++/8/cstdlib" 3 4
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 40 "/usr/include/boost/core/demangle.hpp" 2 3 4
>
>
>
>
>namespace boost
>{
>
>namespace core
>{
>
>inline char const * demangle_alloc( char const * name ) noexcept;
>inline void demangle_free( char const * name ) noexcept;
>
>class scoped_demangled_name
>{
>private:
> char const * m_p;
>
>public:
> explicit scoped_demangled_name( char const * name ) noexcept :
> m_p( demangle_alloc( name ) )
> {
> }
>
> ~scoped_demangled_name() noexcept
> {
> demangle_free( m_p );
> }
>
> char const * get() const noexcept
> {
> return m_p;
> }
>
> scoped_demangled_name( scoped_demangled_name const& ) = delete;
> scoped_demangled_name& operator= ( scoped_demangled_name const& ) = delete;
>};
>
>
>
>
>inline char const * demangle_alloc( char const * name ) noexcept
>{
> int status = 0;
> std::size_t size = 0;
> return abi::__cxa_demangle( name, __null, &size, &status );
>}
>
>inline void demangle_free( char const * name ) noexcept
>{
> std::free( const_cast< char* >( name ) );
>}
>
>inline std::string demangle( char const * name )
>{
> scoped_demangled_name demangled_name( name );
> char const * p = demangled_name.get();
> if( !p )
> p = name;
> return p;
>}
># 120 "/usr/include/boost/core/demangle.hpp" 3 4
>}
>
>}
># 120 "/usr/include/boost/core/typeinfo.hpp" 2 3 4
>
>
>namespace boost
>{
>
>namespace core
>{
>
>
>
>
>
>
>
>typedef std::type_info typeinfo;
>
>
>
>inline std::string demangled_name( core::typeinfo const & ti )
>{
> return core::demangle( ti.name() );
>}
>
>}
>
>}
># 21 "/usr/include/boost/detail/sp_typeinfo.hpp" 2 3 4
>
>namespace boost
>{
>
>namespace detail
>{
>
>typedef boost::core::typeinfo sp_typeinfo;
>
>}
>
>}
># 19 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3 4
>
>
>
>namespace boost
>{
>
>namespace detail
>{
>
>inline void atomic_increment( std::atomic_int_least32_t * pw )
>{
> pw->fetch_add( 1, std::memory_order_relaxed );
>}
>
>inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw )
>{
> return pw->fetch_sub( 1, std::memory_order_acq_rel );
>}
>
>inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw )
>{
>
>
>
>
> std::int_least32_t r = pw->load( std::memory_order_relaxed );
>
> for( ;; )
> {
> if( r == 0 )
> {
> return r;
> }
>
> if( pw->compare_exchange_weak( r, r + 1, std::memory_order_relaxed, std::memory_order_relaxed ) )
> {
> return r;
> }
> }
>}
>
>class sp_counted_base
>{
>private:
>
> sp_counted_base( sp_counted_base const & );
> sp_counted_base & operator= ( sp_counted_base const & );
>
> std::atomic_int_least32_t use_count_;
> std::atomic_int_least32_t weak_count_;
>
>public:
>
> sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
> {
> }
>
> virtual ~sp_counted_base()
> {
> }
>
>
>
>
> virtual void dispose() = 0;
>
>
>
> virtual void destroy()
> {
> delete this;
> }
>
> virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
> virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
> virtual void * get_untyped_deleter() = 0;
>
> void add_ref_copy()
> {
> atomic_increment( &use_count_ );
> }
>
> bool add_ref_lock()
> {
> return atomic_conditional_increment( &use_count_ ) != 0;
> }
>
> void release()
> {
> if( atomic_decrement( &use_count_ ) == 1 )
> {
> dispose();
> weak_release();
> }
> }
>
> void weak_add_ref()
> {
> atomic_increment( &weak_count_ );
> }
>
> void weak_release()
> {
> if( atomic_decrement( &weak_count_ ) == 1 )
> {
> destroy();
> }
> }
>
> long use_count() const
> {
> return use_count_.load( std::memory_order_acquire );
> }
>};
>
>}
>
>}
># 49 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
># 30 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3 4
># 29 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
># 1 "/usr/include/boost/core/addressof.hpp" 1 3 4
># 34 "/usr/include/boost/core/addressof.hpp" 3 4
>namespace boost {
>
>template<class T>
>constexpr inline T*
>addressof(T& o) noexcept
>{
> return __builtin_addressof(o);
>}
>
>}
># 266 "/usr/include/boost/core/addressof.hpp" 3 4
>namespace boost {
>
>template<class T>
>const T* addressof(const T&&) = delete;
>
>}
># 30 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2 3 4
># 41 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>namespace boost
>{
># 51 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>namespace detail
>{
>
>
>
>template<class D> class local_sp_deleter;
>
>template<class D> D * get_local_deleter( D * )
>{
> return 0;
>}
>
>template<class D> D * get_local_deleter( local_sp_deleter<D> * p );
>
>
>
>template<class X> class sp_counted_impl_p: public sp_counted_base
>{
>private:
>
> X * px_;
>
> sp_counted_impl_p( sp_counted_impl_p const & );
> sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
>
> typedef sp_counted_impl_p<X> this_type;
>
>public:
>
> explicit sp_counted_impl_p( X * px ): px_( px )
> {
>
>
>
> }
>
> virtual void dispose()
> {
>
>
>
> boost::checked_delete( px_ );
> }
>
> virtual void * get_deleter( sp_typeinfo const & )
> {
> return 0;
> }
>
> virtual void * get_local_deleter( sp_typeinfo const & )
> {
> return 0;
> }
>
> virtual void * get_untyped_deleter()
> {
> return 0;
> }
># 137 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>};
># 146 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
>{
>private:
>
> P ptr;
> D del;
>
> sp_counted_impl_pd( sp_counted_impl_pd const & );
> sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
>
> typedef sp_counted_impl_pd<P, D> this_type;
>
>public:
>
>
>
> sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
> {
> }
>
> sp_counted_impl_pd( P p ): ptr( p ), del()
> {
> }
>
> virtual void dispose()
> {
> del( ptr );
> }
>
> virtual void * get_deleter( sp_typeinfo const & ti )
> {
> return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
> }
>
> virtual void * get_local_deleter( sp_typeinfo const & ti )
> {
> return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
> }
>
> virtual void * get_untyped_deleter()
> {
> return &reinterpret_cast<char&>( del );
> }
># 217 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
>};
>
>template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
>{
>private:
>
> P p_;
> D d_;
> A a_;
>
> sp_counted_impl_pda( sp_counted_impl_pda const & );
> sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
>
> typedef sp_counted_impl_pda<P, D, A> this_type;
>
>public:
>
>
>
> sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
> {
> }
>
> sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
> {
> }
>
> virtual void dispose()
> {
> d_( p_ );
> }
>
> virtual void destroy()
> {
>
>
> typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;
>
>
>
>
>
>
>
> A2 a2( a_ );
>
> this->~this_type();
>
> a2.deallocate( this, 1 );
> }
>
> virtual void * get_deleter( sp_typeinfo const & ti )
> {
> return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
> }
>
> virtual void * get_local_deleter( sp_typeinfo const & ti )
> {
> return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
> }
>
> virtual void * get_untyped_deleter()
> {
> return &reinterpret_cast<char&>( d_ );
> }
>};
>
>
>
>
>
>}
>
>}
># 31 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp" 1 3 4
># 32 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
># 47 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
>
>
>namespace boost
>{
>
>namespace movelib
>{
>
>template< class T, class D > class unique_ptr;
>
>}
>
>namespace detail
>{
># 71 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
>struct sp_nothrow_tag {};
>
>template< class D > struct sp_inplace_tag
>{
>};
>
>template< class T > class sp_reference_wrapper
>{
>public:
>
> explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
> {
> }
>
> template< class Y > void operator()( Y * p ) const
> {
> (*t_)( p );
> }
>
>private:
>
> T * t_;
>};
>
>template< class D > struct sp_convert_reference
>{
> typedef D type;
>};
>
>template< class D > struct sp_convert_reference< D& >
>{
> typedef sp_reference_wrapper< D > type;
>};
>
>class weak_count;
>
>class shared_count
>{
>private:
>
> sp_counted_base * pi_;
>
>
>
>
>
> friend class weak_count;
>
>public:
>
> constexpr shared_count(): pi_(0)
>
>
>
> {
> }
>
> constexpr explicit shared_count( sp_counted_base * pi ): pi_( pi )
>
>
>
> {
> }
>
> template<class Y> explicit shared_count( Y * p ): pi_( 0 )
>
>
>
> {
>
>
> try
> {
> pi_ = new sp_counted_impl_p<Y>( p );
> }
> catch(...)
> {
> boost::checked_delete( p );
> throw;
> }
># 163 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
>
> template<class P, class D> shared_count( P p, D d ): pi_(0)
>
>
>
>
> {
>
>
>
>
>
> try
> {
> pi_ = new sp_counted_impl_pd<P, D>(p, d);
> }
> catch(...)
> {
> d(p);
> throw;
> }
># 200 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
> template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
>
>
>
> {
>
>
> try
> {
> pi_ = new sp_counted_impl_pd< P, D >( p );
> }
> catch( ... )
> {
> D::operator_fn( p );
> throw;
> }
># 232 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
> template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
>
>
>
> {
> typedef sp_counted_impl_pda<P, D, A> impl_type;
>
>
>
> typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
>
>
>
>
>
>
>
> A2 a2( a );
>
>
>
> try
> {
> pi_ = a2.allocate( 1 );
> ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
> }
> catch(...)
> {
> d( p );
>
> if( pi_ != 0 )
> {
> a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
> }
>
> throw;
> }
># 289 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
> template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
>
>
>
> {
> typedef sp_counted_impl_pda< P, D, A > impl_type;
>
>
>
> typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
>
>
>
>
>
>
>
> A2 a2( a );
>
>
>
> try
> {
> pi_ = a2.allocate( 1 );
> ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
> }
> catch(...)
> {
> D::operator_fn( p );
>
> if( pi_ != 0 )
> {
> a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
> }
>
> throw;
> }
># 346 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> }
>
>
>
>
>
>
>
> template<class Y>
> explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
>
>
>
> {
># 369 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> r.release();
> }
>
>
>
>
>
> template<class Y, class D>
> explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )
>
>
>
> {
> typedef typename sp_convert_reference<D>::type D2;
>
> D2 d2( r.get_deleter() );
> pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
># 396 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> r.release();
> }
>
>
>
> template<class Y, class D>
> explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 )
>
>
>
> {
> typedef typename sp_convert_reference<D>::type D2;
>
> D2 d2( r.get_deleter() );
> pi_ = new sp_counted_impl_pd< typename boost::movelib::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
># 421 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
> r.release();
> }
>
> ~shared_count()
> {
> if( pi_ != 0 ) pi_->release();
>
>
>
> }
>
> shared_count(shared_count const & r): pi_(r.pi_)
>
>
>
> {
> if( pi_ != 0 ) pi_->add_ref_copy();
> }
>
>
>
> shared_count(shared_count && r): pi_(r.pi_)
>
>
>
> {
> r.pi_ = 0;
> }
>
>
>
> explicit shared_count(weak_count const & r);
> shared_count( weak_count const & r, sp_nothrow_tag );
>
> shared_count & operator= (shared_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if( tmp != 0 ) tmp->add_ref_copy();
> if( pi_ != 0 ) pi_->release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> void swap(shared_count & r)
> {
> sp_counted_base * tmp = r.pi_;
> r.pi_ = pi_;
> pi_ = tmp;
> }
>
> long use_count() const
> {
> return pi_ != 0? pi_->use_count(): 0;
> }
>
> bool unique() const
> {
> return use_count() == 1;
> }
>
> bool empty() const
> {
> return pi_ == 0;
> }
>
> friend inline bool operator==(shared_count const & a, shared_count const & b)
> {
> return a.pi_ == b.pi_;
> }
>
> friend inline bool operator<(shared_count const & a, shared_count const & b)
> {
> return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
> }
>
> void * get_deleter( sp_typeinfo const & ti ) const
> {
> return pi_? pi_->get_deleter( ti ): 0;
> }
>
> void * get_local_deleter( sp_typeinfo const & ti ) const
> {
> return pi_? pi_->get_local_deleter( ti ): 0;
> }
>
> void * get_untyped_deleter() const
> {
> return pi_? pi_->get_untyped_deleter(): 0;
> }
>};
>
>
>class weak_count
>{
>private:
>
> sp_counted_base * pi_;
>
>
>
>
>
> friend class shared_count;
>
>public:
>
> constexpr weak_count(): pi_(0)
>
>
>
> {
> }
>
> weak_count(shared_count const & r): pi_(r.pi_)
>
>
>
> {
> if(pi_ != 0) pi_->weak_add_ref();
> }
>
> weak_count(weak_count const & r): pi_(r.pi_)
>
>
>
> {
> if(pi_ != 0) pi_->weak_add_ref();
> }
>
>
>
>
>
> weak_count(weak_count && r): pi_(r.pi_)
>
>
>
> {
> r.pi_ = 0;
> }
>
>
>
> ~weak_count()
> {
> if(pi_ != 0) pi_->weak_release();
>
>
>
> }
>
> weak_count & operator= (shared_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if(tmp != 0) tmp->weak_add_ref();
> if(pi_ != 0) pi_->weak_release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> weak_count & operator= (weak_count const & r)
> {
> sp_counted_base * tmp = r.pi_;
>
> if( tmp != pi_ )
> {
> if(tmp != 0) tmp->weak_add_ref();
> if(pi_ != 0) pi_->weak_release();
> pi_ = tmp;
> }
>
> return *this;
> }
>
> void swap(weak_count & r)
> {
> sp_counted_base * tmp = r.pi_;
> r.pi_ = pi_;
> pi_ = tmp;
> }
>
> long use_count() const
> {
> return pi_ != 0? pi_->use_count(): 0;
> }
>
> bool empty() const
> {
> return pi_ == 0;
> }
>
> friend inline bool operator==(weak_count const & a, weak_count const & b)
> {
> return a.pi_ == b.pi_;
> }
>
> friend inline bool operator<(weak_count const & a, weak_count const & b)
> {
> return std::less<sp_counted_base *>()(a.pi_, b.pi_);
> }
>};
>
>inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
>
>
>
>{
> if( pi_ == 0 || !pi_->add_ref_lock() )
> {
> boost::throw_exception( boost::bad_weak_ptr() );
> }
>}
>
>inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
>
>
>
>{
> if( pi_ != 0 && !pi_->add_ref_lock() )
> {
> pi_ = 0;
> }
>}
>
>}
>
>}
>
>
>#pragma GCC diagnostic pop
># 29 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3 4
># 35 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>template< class Y, class T > struct sp_convertible
>{
> typedef char (&yes) [1];
> typedef char (&no) [2];
>
> static yes f( T* );
> static no f( ... );
>
> enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
>};
>
>template< class Y, class T > struct sp_convertible< Y, T[] >
>{
> enum _vt { value = false };
>};
>
>template< class Y, class T > struct sp_convertible< Y[], T[] >
>{
> enum _vt { value = sp_convertible< Y[1], T[1] >::value };
>};
>
>template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
>{
> enum _vt { value = sp_convertible< Y[1], T[1] >::value };
>};
>
>struct sp_empty
>{
>};
>
>template< bool > struct sp_enable_if_convertible_impl;
>
>template<> struct sp_enable_if_convertible_impl<true>
>{
> typedef sp_empty type;
>};
>
>template<> struct sp_enable_if_convertible_impl<false>
>{
>};
>
>template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
>{
>};
>
>}
>
>}
># 31 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 1 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 1 3 4
># 23 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>
>
>
>
>
>
> typedef std::nullptr_t sp_nullptr_t;
>
>
>
>}
>
>}
># 32 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
># 1 "/usr/include/boost/smart_ptr/detail/sp_noexcept.hpp" 1 3 4
># 34 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3 4
># 25 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 1 3 4
># 47 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 1 3 4
># 18 "/usr/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 1 3 4
># 28 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
># 1 "/usr/include/boost/predef.h" 1 3 4
># 13 "/usr/include/boost/predef.h" 3 4
># 1 "/usr/include/boost/predef/language.h" 1 3 4
># 13 "/usr/include/boost/predef/language.h" 3 4
># 1 "/usr/include/boost/predef/language/stdc.h" 1 3 4
># 12 "/usr/include/boost/predef/language/stdc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/language/stdc.h" 2 3 4
># 53 "/usr/include/boost/predef/language/stdc.h" 3 4
>
># 14 "/usr/include/boost/predef/language.h" 2 3 4
># 1 "/usr/include/boost/predef/language/stdcpp.h" 1 3 4
># 12 "/usr/include/boost/predef/language/stdcpp.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/language/stdcpp.h" 2 3 4
># 115 "/usr/include/boost/predef/language/stdcpp.h" 3 4
>
>
>
>
>
>
>
># 15 "/usr/include/boost/predef/language.h" 2 3 4
># 1 "/usr/include/boost/predef/language/objc.h" 1 3 4
># 12 "/usr/include/boost/predef/language/objc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/language/objc.h" 2 3 4
># 42 "/usr/include/boost/predef/language/objc.h" 3 4
>
># 16 "/usr/include/boost/predef/language.h" 2 3 4
># 14 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture.h" 3 4
># 1 "/usr/include/boost/predef/architecture/alpha.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/alpha.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/alpha.h" 2 3 4
># 59 "/usr/include/boost/predef/architecture/alpha.h" 3 4
>
># 14 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/arm.h" 1 3 4
># 14 "/usr/include/boost/predef/architecture/arm.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/architecture/arm.h" 2 3 4
># 75 "/usr/include/boost/predef/architecture/arm.h" 3 4
>
># 15 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/blackfin.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/blackfin.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/blackfin.h" 2 3 4
># 46 "/usr/include/boost/predef/architecture/blackfin.h" 3 4
>
># 16 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/convex.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/convex.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/convex.h" 2 3 4
># 65 "/usr/include/boost/predef/architecture/convex.h" 3 4
>
># 17 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/ia64.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/ia64.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/ia64.h" 2 3 4
># 49 "/usr/include/boost/predef/architecture/ia64.h" 3 4
>
># 18 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/m68k.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/m68k.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/m68k.h" 2 3 4
># 82 "/usr/include/boost/predef/architecture/m68k.h" 3 4
>
># 19 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/mips.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/mips.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/mips.h" 2 3 4
># 73 "/usr/include/boost/predef/architecture/mips.h" 3 4
>
># 20 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/parisc.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/parisc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/parisc.h" 2 3 4
># 64 "/usr/include/boost/predef/architecture/parisc.h" 3 4
>
># 21 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/ppc.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/ppc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/ppc.h" 2 3 4
># 72 "/usr/include/boost/predef/architecture/ppc.h" 3 4
>
># 22 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/pyramid.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/pyramid.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/pyramid.h" 2 3 4
># 42 "/usr/include/boost/predef/architecture/pyramid.h" 3 4
>
># 23 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/rs6k.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/rs6k.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/rs6k.h" 2 3 4
># 56 "/usr/include/boost/predef/architecture/rs6k.h" 3 4
>
># 24 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/sparc.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/sparc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/sparc.h" 2 3 4
># 54 "/usr/include/boost/predef/architecture/sparc.h" 3 4
>
># 25 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/superh.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/superh.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/superh.h" 2 3 4
># 67 "/usr/include/boost/predef/architecture/superh.h" 3 4
>
># 26 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/sys370.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/sys370.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/sys370.h" 2 3 4
># 43 "/usr/include/boost/predef/architecture/sys370.h" 3 4
>
># 27 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/sys390.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/sys390.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/sys390.h" 2 3 4
># 43 "/usr/include/boost/predef/architecture/sys390.h" 3 4
>
># 28 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/x86.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/predef/architecture/x86/32.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/x86/32.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/x86/32.h" 2 3 4
># 82 "/usr/include/boost/predef/architecture/x86/32.h" 3 4
># 1 "/usr/include/boost/predef/architecture/x86.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/predef/architecture/x86/32.h" 1 3 4
># 87 "/usr/include/boost/predef/architecture/x86/32.h" 3 4
>
># 9 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/x86/64.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/x86/64.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/x86/64.h" 2 3 4
># 45 "/usr/include/boost/predef/architecture/x86/64.h" 3 4
># 1 "/usr/include/boost/predef/architecture/x86.h" 1 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/predef/architecture/x86/32.h" 1 3 4
># 87 "/usr/include/boost/predef/architecture/x86/32.h" 3 4
>
># 9 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/x86/64.h" 1 3 4
># 50 "/usr/include/boost/predef/architecture/x86/64.h" 3 4
>
># 10 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
># 38 "/usr/include/boost/predef/architecture/x86.h" 3 4
>
># 46 "/usr/include/boost/predef/architecture/x86/64.h" 2 3 4
>
>
>
>
>
># 10 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
># 38 "/usr/include/boost/predef/architecture/x86.h" 3 4
>
># 83 "/usr/include/boost/predef/architecture/x86/32.h" 2 3 4
>
>
>
>
>
># 9 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/x86/64.h" 1 3 4
># 50 "/usr/include/boost/predef/architecture/x86/64.h" 3 4
>
># 10 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
># 38 "/usr/include/boost/predef/architecture/x86.h" 3 4
>
># 29 "/usr/include/boost/predef/architecture.h" 2 3 4
># 1 "/usr/include/boost/predef/architecture/z.h" 1 3 4
># 12 "/usr/include/boost/predef/architecture/z.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/architecture/z.h" 2 3 4
># 42 "/usr/include/boost/predef/architecture/z.h" 3 4
>
># 30 "/usr/include/boost/predef/architecture.h" 2 3 4
># 15 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler.h" 3 4
># 1 "/usr/include/boost/predef/compiler/borland.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/borland.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/borland.h" 2 3 4
># 58 "/usr/include/boost/predef/compiler/borland.h" 3 4
>
># 14 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/clang.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/clang.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/clang.h" 3 4
>
># 15 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/comeau.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/comeau.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/comeau.h" 2 3 4
># 56 "/usr/include/boost/predef/compiler/comeau.h" 3 4
>
># 16 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/compaq.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/compaq.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/compaq.h" 2 3 4
># 61 "/usr/include/boost/predef/compiler/compaq.h" 3 4
>
># 17 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/diab.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/diab.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/diab.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/diab.h" 3 4
>
># 18 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/digitalmars.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/digitalmars.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/digitalmars.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/digitalmars.h" 3 4
>
># 19 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/dignus.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/dignus.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/dignus.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/dignus.h" 3 4
>
># 20 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/edg.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/edg.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/edg.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/edg.h" 3 4
>
># 21 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/ekopath.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/ekopath.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/ekopath.h" 2 3 4
># 52 "/usr/include/boost/predef/compiler/ekopath.h" 3 4
>
># 22 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/gcc_xml.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/gcc_xml.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/gcc_xml.h" 2 3 4
># 48 "/usr/include/boost/predef/compiler/gcc_xml.h" 3 4
>
># 23 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/gcc.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/gcc.h" 3 4
># 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
># 51 "/usr/include/boost/predef/compiler/clang.h" 3 4
>
># 14 "/usr/include/boost/predef/compiler/gcc.h" 2 3 4
>
>
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 17 "/usr/include/boost/predef/compiler/gcc.h" 2 3 4
># 55 "/usr/include/boost/predef/compiler/gcc.h" 3 4
># 1 "/usr/include/boost/predef/detail/comp_detected.h" 1 3 4
># 56 "/usr/include/boost/predef/compiler/gcc.h" 2 3 4
>
>
>
>
>
>
>
>
># 24 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/greenhills.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/greenhills.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/greenhills.h" 2 3 4
># 61 "/usr/include/boost/predef/compiler/greenhills.h" 3 4
>
># 25 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/hp_acc.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/hp_acc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/hp_acc.h" 2 3 4
># 56 "/usr/include/boost/predef/compiler/hp_acc.h" 3 4
>
># 26 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/iar.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/iar.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/iar.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/iar.h" 3 4
>
># 27 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/ibm.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/ibm.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/ibm.h" 2 3 4
># 67 "/usr/include/boost/predef/compiler/ibm.h" 3 4
>
># 28 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/intel.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/intel.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/intel.h" 2 3 4
># 74 "/usr/include/boost/predef/compiler/intel.h" 3 4
>
># 29 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/kai.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/kai.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/kai.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/kai.h" 3 4
>
># 30 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/llvm.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/llvm.h" 3 4
># 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
># 51 "/usr/include/boost/predef/compiler/clang.h" 3 4
>
># 14 "/usr/include/boost/predef/compiler/llvm.h" 2 3 4
>
>
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 17 "/usr/include/boost/predef/compiler/llvm.h" 2 3 4
># 52 "/usr/include/boost/predef/compiler/llvm.h" 3 4
>
># 31 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/metaware.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/metaware.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/metaware.h" 2 3 4
># 48 "/usr/include/boost/predef/compiler/metaware.h" 3 4
>
># 32 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/metrowerks.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/metrowerks.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/metrowerks.h" 2 3 4
># 72 "/usr/include/boost/predef/compiler/metrowerks.h" 3 4
>
># 33 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/microtec.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/microtec.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/microtec.h" 2 3 4
># 48 "/usr/include/boost/predef/compiler/microtec.h" 3 4
>
># 34 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/mpw.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/mpw.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/mpw.h" 2 3 4
># 58 "/usr/include/boost/predef/compiler/mpw.h" 3 4
>
># 35 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/palm.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/palm.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/palm.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/palm.h" 3 4
>
># 36 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/pgi.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/pgi.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/pgi.h" 2 3 4
># 55 "/usr/include/boost/predef/compiler/pgi.h" 3 4
>
># 37 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 2 3 4
># 61 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 3 4
>
># 38 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/sunpro.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/sunpro.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/sunpro.h" 2 3 4
># 71 "/usr/include/boost/predef/compiler/sunpro.h" 3 4
>
># 39 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/tendra.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/tendra.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/tendra.h" 2 3 4
># 48 "/usr/include/boost/predef/compiler/tendra.h" 3 4
>
># 40 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/visualc.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/visualc.h" 3 4
># 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
># 51 "/usr/include/boost/predef/compiler/clang.h" 3 4
>
># 14 "/usr/include/boost/predef/compiler/visualc.h" 2 3 4
>
>
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 17 "/usr/include/boost/predef/compiler/visualc.h" 2 3 4
># 100 "/usr/include/boost/predef/compiler/visualc.h" 3 4
>
># 41 "/usr/include/boost/predef/compiler.h" 2 3 4
># 1 "/usr/include/boost/predef/compiler/watcom.h" 1 3 4
># 12 "/usr/include/boost/predef/compiler/watcom.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/compiler/watcom.h" 2 3 4
># 51 "/usr/include/boost/predef/compiler/watcom.h" 3 4
>
># 42 "/usr/include/boost/predef/compiler.h" 2 3 4
># 16 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/library.h" 1 3 4
># 13 "/usr/include/boost/predef/library.h" 3 4
># 1 "/usr/include/boost/predef/library/c.h" 1 3 4
># 13 "/usr/include/boost/predef/library/c.h" 3 4
># 1 "/usr/include/boost/predef/library/c/_prefix.h" 1 3 4
># 11 "/usr/include/boost/predef/library/c/_prefix.h" 3 4
># 1 "/usr/include/boost/predef/detail/_cassert.h" 1 3 4
># 12 "/usr/include/boost/predef/detail/_cassert.h" 3 4
># 1 "/usr/include/c++/8/cassert" 1 3 4
># 41 "/usr/include/c++/8/cassert" 3 4
> 
># 42 "/usr/include/c++/8/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)
> throw () __attribute__ ((__noreturn__));
>
>
>extern void __assert_perror_fail (int __errnum, const char *__file,
> unsigned int __line, const char *__function)
> throw () __attribute__ ((__noreturn__));
>
>
>
>
>extern void __assert (const char *__assertion, const char *__file, int __line)
> throw () __attribute__ ((__noreturn__));
>
>
>}
># 44 "/usr/include/c++/8/cassert" 2 3
># 13 "/usr/include/boost/predef/detail/_cassert.h" 2 3 4
># 12 "/usr/include/boost/predef/library/c/_prefix.h" 2 3 4
># 14 "/usr/include/boost/predef/library/c.h" 2 3 4
>
># 1 "/usr/include/boost/predef/library/c/cloudabi.h" 1 3 4
># 13 "/usr/include/boost/predef/library/c/cloudabi.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 14 "/usr/include/boost/predef/library/c/cloudabi.h" 2 3 4
># 53 "/usr/include/boost/predef/library/c/cloudabi.h" 3 4
>
># 16 "/usr/include/boost/predef/library/c.h" 2 3 4
># 1 "/usr/include/boost/predef/library/c/gnu.h" 1 3 4
># 12 "/usr/include/boost/predef/library/c/gnu.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/library/c/gnu.h" 2 3 4
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 18 "/usr/include/boost/predef/library/c/gnu.h" 2 3 4
># 61 "/usr/include/boost/predef/library/c/gnu.h" 3 4
>
># 17 "/usr/include/boost/predef/library/c.h" 2 3 4
># 1 "/usr/include/boost/predef/library/c/uc.h" 1 3 4
># 14 "/usr/include/boost/predef/library/c/uc.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/c/uc.h" 2 3 4
># 47 "/usr/include/boost/predef/library/c/uc.h" 3 4
>
># 18 "/usr/include/boost/predef/library/c.h" 2 3 4
># 1 "/usr/include/boost/predef/library/c/vms.h" 1 3 4
># 14 "/usr/include/boost/predef/library/c/vms.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/c/vms.h" 2 3 4
># 47 "/usr/include/boost/predef/library/c/vms.h" 3 4
>
># 19 "/usr/include/boost/predef/library/c.h" 2 3 4
># 1 "/usr/include/boost/predef/library/c/zos.h" 1 3 4
># 14 "/usr/include/boost/predef/library/c/zos.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/c/zos.h" 2 3 4
># 56 "/usr/include/boost/predef/library/c/zos.h" 3 4
>
># 20 "/usr/include/boost/predef/library/c.h" 2 3 4
># 14 "/usr/include/boost/predef/library.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std.h" 1 3 4
># 12 "/usr/include/boost/predef/library/std.h" 3 4
># 1 "/usr/include/boost/predef/library/std/_prefix.h" 1 3 4
># 21 "/usr/include/boost/predef/library/std/_prefix.h" 3 4
># 1 "/usr/include/boost/predef/detail/_exception.h" 1 3 4
># 22 "/usr/include/boost/predef/library/std/_prefix.h" 2 3 4
># 13 "/usr/include/boost/predef/library/std.h" 2 3 4
>
># 1 "/usr/include/boost/predef/library/std/cxx.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/cxx.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/cxx.h" 2 3 4
># 46 "/usr/include/boost/predef/library/std/cxx.h" 3 4
>
># 15 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/dinkumware.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/dinkumware.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/dinkumware.h" 2 3 4
># 52 "/usr/include/boost/predef/library/std/dinkumware.h" 3 4
>
># 16 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/libcomo.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/libcomo.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/libcomo.h" 2 3 4
># 47 "/usr/include/boost/predef/library/std/libcomo.h" 3 4
>
># 17 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/modena.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/modena.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/modena.h" 2 3 4
># 45 "/usr/include/boost/predef/library/std/modena.h" 3 4
>
># 18 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/msl.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/msl.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/msl.h" 2 3 4
># 53 "/usr/include/boost/predef/library/std/msl.h" 3 4
>
># 19 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/roguewave.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/roguewave.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/roguewave.h" 2 3 4
># 56 "/usr/include/boost/predef/library/std/roguewave.h" 3 4
>
># 20 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/sgi.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/sgi.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/sgi.h" 2 3 4
># 51 "/usr/include/boost/predef/library/std/sgi.h" 3 4
>
># 21 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/stdcpp3.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/stdcpp3.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/stdcpp3.h" 2 3 4
># 53 "/usr/include/boost/predef/library/std/stdcpp3.h" 3 4
>
># 22 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/stlport.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/stlport.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/stlport.h" 2 3 4
># 59 "/usr/include/boost/predef/library/std/stlport.h" 3 4
>
># 23 "/usr/include/boost/predef/library/std.h" 2 3 4
># 1 "/usr/include/boost/predef/library/std/vacpp.h" 1 3 4
># 14 "/usr/include/boost/predef/library/std/vacpp.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 15 "/usr/include/boost/predef/library/std/vacpp.h" 2 3 4
># 44 "/usr/include/boost/predef/library/std/vacpp.h" 3 4
>
># 24 "/usr/include/boost/predef/library/std.h" 2 3 4
># 15 "/usr/include/boost/predef/library.h" 2 3 4
># 17 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/os.h" 1 3 4
># 14 "/usr/include/boost/predef/os.h" 3 4
># 1 "/usr/include/boost/predef/os/aix.h" 1 3 4
># 12 "/usr/include/boost/predef/os/aix.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/aix.h" 2 3 4
># 66 "/usr/include/boost/predef/os/aix.h" 3 4
>
># 15 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/amigaos.h" 1 3 4
># 12 "/usr/include/boost/predef/os/amigaos.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/amigaos.h" 2 3 4
># 46 "/usr/include/boost/predef/os/amigaos.h" 3 4
>
># 16 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/android.h" 1 3 4
># 12 "/usr/include/boost/predef/os/android.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/android.h" 2 3 4
># 45 "/usr/include/boost/predef/os/android.h" 3 4
>
># 17 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/beos.h" 1 3 4
># 12 "/usr/include/boost/predef/os/beos.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/beos.h" 2 3 4
># 45 "/usr/include/boost/predef/os/beos.h" 3 4
>
># 18 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 16 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/macos.h" 1 3 4
># 17 "/usr/include/boost/predef/os/macos.h" 3 4
># 1 "/usr/include/boost/predef/os/ios.h" 1 3 4
># 51 "/usr/include/boost/predef/os/ios.h" 3 4
>
># 18 "/usr/include/boost/predef/os/macos.h" 2 3 4
>
>
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 21 "/usr/include/boost/predef/os/macos.h" 2 3 4
># 65 "/usr/include/boost/predef/os/macos.h" 3 4
>
># 17 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 20 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 52 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 11 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 94 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 95 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 11 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 94 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 95 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 11 "/usr/include/boost/predef/os/bsd/free.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 94 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 95 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 11 "/usr/include/boost/predef/os/bsd/open.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 94 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 95 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 11 "/usr/include/boost/predef/os/bsd/net.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 94 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 95 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
>
>
>
># 12 "/usr/include/boost/predef/os/bsd/net.h" 2 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
>
>
>
># 12 "/usr/include/boost/predef/os/bsd/open.h" 2 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
>
>
>
># 12 "/usr/include/boost/predef/os/bsd/free.h" 2 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
>
>
>
># 12 "/usr/include/boost/predef/os/bsd/dragonfly.h" 2 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
>
>
>
># 12 "/usr/include/boost/predef/os/bsd/bsdi.h" 2 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 53 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 54 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 55 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 56 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 57 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 103 "/usr/include/boost/predef/os/bsd.h" 3 4
>
># 19 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/cygwin.h" 1 3 4
># 12 "/usr/include/boost/predef/os/cygwin.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/cygwin.h" 2 3 4
># 45 "/usr/include/boost/predef/os/cygwin.h" 3 4
>
># 20 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/haiku.h" 1 3 4
># 13 "/usr/include/boost/predef/os/haiku.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 14 "/usr/include/boost/predef/os/haiku.h" 2 3 4
># 46 "/usr/include/boost/predef/os/haiku.h" 3 4
>
># 21 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/hpux.h" 1 3 4
># 12 "/usr/include/boost/predef/os/hpux.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/hpux.h" 2 3 4
># 47 "/usr/include/boost/predef/os/hpux.h" 3 4
>
># 22 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/irix.h" 1 3 4
># 12 "/usr/include/boost/predef/os/irix.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/irix.h" 2 3 4
># 46 "/usr/include/boost/predef/os/irix.h" 3 4
>
># 23 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/ios.h" 1 3 4
># 51 "/usr/include/boost/predef/os/ios.h" 3 4
>
># 24 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/linux.h" 1 3 4
># 12 "/usr/include/boost/predef/os/linux.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/linux.h" 2 3 4
># 38 "/usr/include/boost/predef/os/linux.h" 3 4
># 1 "/usr/include/boost/predef/detail/os_detected.h" 1 3 4
># 39 "/usr/include/boost/predef/os/linux.h" 2 3 4
>
>
>
>
>
>
>
>
># 25 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/macos.h" 1 3 4
># 65 "/usr/include/boost/predef/os/macos.h" 3 4
>
># 26 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/os400.h" 1 3 4
># 12 "/usr/include/boost/predef/os/os400.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/os400.h" 2 3 4
># 45 "/usr/include/boost/predef/os/os400.h" 3 4
>
># 27 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/qnxnto.h" 1 3 4
># 12 "/usr/include/boost/predef/os/qnxnto.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/qnxnto.h" 2 3 4
># 59 "/usr/include/boost/predef/os/qnxnto.h" 3 4
>
># 28 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/solaris.h" 1 3 4
># 12 "/usr/include/boost/predef/os/solaris.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/solaris.h" 2 3 4
># 46 "/usr/include/boost/predef/os/solaris.h" 3 4
>
># 29 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/unix.h" 1 3 4
># 12 "/usr/include/boost/predef/os/unix.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/unix.h" 2 3 4
># 75 "/usr/include/boost/predef/os/unix.h" 3 4
>
>
># 30 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/vms.h" 1 3 4
># 12 "/usr/include/boost/predef/os/vms.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/os/vms.h" 2 3 4
># 52 "/usr/include/boost/predef/os/vms.h" 3 4
>
># 31 "/usr/include/boost/predef/os.h" 2 3 4
># 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
># 51 "/usr/include/boost/predef/os/windows.h" 3 4
>
># 32 "/usr/include/boost/predef/os.h" 2 3 4
># 18 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/other.h" 1 3 4
># 13 "/usr/include/boost/predef/other.h" 3 4
># 1 "/usr/include/boost/predef/other/endian.h" 1 3 4
># 12 "/usr/include/boost/predef/other/endian.h" 3 4
># 1 "/usr/include/boost/predef/make.h" 1 3 4
># 13 "/usr/include/boost/predef/other/endian.h" 2 3 4
># 1 "/usr/include/boost/predef/library/c/gnu.h" 1 3 4
># 61 "/usr/include/boost/predef/library/c/gnu.h" 3 4
>
># 14 "/usr/include/boost/predef/other/endian.h" 2 3 4
># 1 "/usr/include/boost/predef/os/macos.h" 1 3 4
># 65 "/usr/include/boost/predef/os/macos.h" 3 4
>
># 15 "/usr/include/boost/predef/other/endian.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
># 94 "/usr/include/boost/predef/os/bsd.h" 3 4
># 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
># 48 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
>
># 95 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
># 50 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
>
># 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
># 67 "/usr/include/boost/predef/os/bsd/free.h" 3 4
>
># 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
># 251 "/usr/include/boost/predef/os/bsd/open.h" 3 4
>
># 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
># 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
># 84 "/usr/include/boost/predef/os/bsd/net.h" 3 4
>
># 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
>
>
>
>
>
># 16 "/usr/include/boost/predef/other/endian.h" 2 3 4
># 1 "/usr/include/boost/predef/os/android.h" 1 3 4
># 45 "/usr/include/boost/predef/os/android.h" 3 4
>
># 17 "/usr/include/boost/predef/other/endian.h" 2 3 4
># 195 "/usr/include/boost/predef/other/endian.h" 3 4
>
>
>
>
>
>
>
>
>
>
># 14 "/usr/include/boost/predef/other.h" 2 3 4
># 19 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/platform.h" 1 3 4
># 20 "/usr/include/boost/predef.h" 2 3 4
># 1 "/usr/include/boost/predef/hardware.h" 1 3 4
># 14 "/usr/include/boost/predef/hardware.h" 3 4
># 1 "/usr/include/boost/predef/hardware/simd.h" 1 3 4
># 9 "/usr/include/boost/predef/hardware/simd.h" 3 4
># 1 "/usr/include/boost/predef/hardware/simd/x86.h" 1 3 4
># 13 "/usr/include/boost/predef/hardware/simd/x86.h" 3 4
># 1 "/usr/include/boost/predef/hardware/simd/x86/versions.h" 1 3 4
># 14 "/usr/include/boost/predef/hardware/simd/x86.h" 2 3 4
># 123 "/usr/include/boost/predef/hardware/simd/x86.h" 3 4
>
># 10 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
># 1 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 1 3 4
># 13 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 3 4
># 1 "/usr/include/boost/predef/hardware/simd/x86_amd/versions.h" 1 3 4
># 14 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 2 3 4
># 87 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 3 4
>
># 11 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
># 1 "/usr/include/boost/predef/hardware/simd/arm.h" 1 3 4
># 13 "/usr/include/boost/predef/hardware/simd/arm.h" 3 4
># 1 "/usr/include/boost/predef/hardware/simd/arm/versions.h" 1 3 4
># 14 "/usr/include/boost/predef/hardware/simd/arm.h" 2 3 4
># 59 "/usr/include/boost/predef/hardware/simd/arm.h" 3 4
>
># 12 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
># 1 "/usr/include/boost/predef/hardware/simd/ppc.h" 1 3 4
># 13 "/usr/include/boost/predef/hardware/simd/ppc.h" 3 4
># 1 "/usr/include/boost/predef/hardware/simd/ppc/versions.h" 1 3 4
># 14 "/usr/include/boost/predef/hardware/simd/ppc.h" 2 3 4
># 69 "/usr/include/boost/predef/hardware/simd/ppc.h" 3 4
>
># 13 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
># 119 "/usr/include/boost/predef/hardware/simd.h" 3 4
>
># 15 "/usr/include/boost/predef/hardware.h" 2 3 4
># 21 "/usr/include/boost/predef.h" 2 3 4
>
># 1 "/usr/include/boost/predef/version.h" 1 3 4
># 23 "/usr/include/boost/predef.h" 2 3 4
># 29 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 2 3 4
># 119 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>inline void yield( unsigned k )
>{
> if( k < 4 )
> {
> }
>
> else if( k < 16 )
> {
> __asm__ __volatile__( "rep; nop" : : : "memory" );
> }
>
> else if( k < 32 || k & 1 )
> {
> sched_yield();
> }
> else
> {
>
> struct timespec rqtp = { 0, 0 };
>
>
>
>
> rqtp.tv_sec = 0;
> rqtp.tv_nsec = 1000;
>
> nanosleep( &rqtp, 0 );
> }
>}
>
>}
>
>}
># 19 "/usr/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 2 3 4
>
>
>namespace boost
>{
>
>namespace detail
>{
>
>class spinlock
>{
>public:
>
> std::atomic_flag v_;
>
>public:
>
> bool try_lock()
> {
> return !v_.test_and_set( std::memory_order_acquire );
> }
>
> void lock()
> {
> for( unsigned k = 0; !try_lock(); ++k )
> {
> boost::detail::yield( k );
> }
> }
>
> void unlock()
> {
> v_ .clear( std::memory_order_release );
> }
>
>public:
>
> class scoped_lock
> {
> private:
>
> spinlock & sp_;
>
> scoped_lock( scoped_lock const & );
> scoped_lock & operator=( scoped_lock const & );
>
> public:
>
> explicit scoped_lock( spinlock & sp ): sp_( sp )
> {
> sp.lock();
> }
>
> ~scoped_lock()
> {
> sp_.unlock();
> }
> };
>};
>
>}
>}
># 48 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 2 3 4
># 26 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4
>
>
>namespace boost
>{
>
>namespace detail
>{
>
>template< int M > class spinlock_pool
>{
>private:
>
> static spinlock pool_[ 41 ];
>
>public:
>
> static spinlock & spinlock_for( void const * pv )
> {
>
>
>
> std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
>
> return pool_[ i ];
> }
>
> class scoped_lock
> {
> private:
>
> spinlock & sp_;
>
> scoped_lock( scoped_lock const & );
> scoped_lock & operator=( scoped_lock const & );
>
> public:
>
> explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
> {
> sp_.lock();
> }
>
> ~scoped_lock()
> {
> sp_.unlock();
> }
> };
>};
>
>template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
>{
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
> { { 0 } }
>};
>
>}
>}
># 37 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
># 53 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
>
>
>namespace boost
>{
>
>template<class T> class shared_ptr;
>template<class T> class weak_ptr;
>template<class T> class enable_shared_from_this;
>class enable_shared_from_raw;
>
>namespace movelib
>{
>
> template< class T, class D > class unique_ptr;
>
>}
>
>namespace detail
>{
>
>
>
>template< class T > struct sp_element
>{
> typedef T type;
>};
>
>
>
>template< class T > struct sp_element< T[] >
>{
> typedef T type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_element< T[N] >
>{
> typedef T type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_dereference
>{
> typedef T & type;
>};
>
>template<> struct sp_dereference< void >
>{
> typedef void type;
>};
>
>
>
>template<> struct sp_dereference< void const >
>{
> typedef void type;
>};
>
>template<> struct sp_dereference< void volatile >
>{
> typedef void type;
>};
>
>template<> struct sp_dereference< void const volatile >
>{
> typedef void type;
>};
>
>
>
>
>
>template< class T > struct sp_dereference< T[] >
>{
> typedef void type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_dereference< T[N] >
>{
> typedef void type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_member_access
>{
> typedef T * type;
>};
>
>
>
>template< class T > struct sp_member_access< T[] >
>{
> typedef void type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_member_access< T[N] >
>{
> typedef void type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_array_access
>{
> typedef void type;
>};
>
>
>
>template< class T > struct sp_array_access< T[] >
>{
> typedef T & type;
>};
>
>
>
>template< class T, std::size_t N > struct sp_array_access< T[N] >
>{
> typedef T & type;
>};
>
>
>
>
>
>
>
>template< class T > struct sp_extent
>{
> enum _vt { value = 0 };
>};
>
>
>
>template< class T, std::size_t N > struct sp_extent< T[N] >
>{
> enum _vt { value = N };
>};
>
>
>
>
>
>template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
>{
> if( pe != 0 )
> {
> pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
> }
>}
>
>template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
># 242 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>inline void sp_enable_shared_from_this( ... )
>{
>}
>
>
>
>
>
>
>
>template< class T, class R > struct sp_enable_if_auto_ptr
>{
>};
>
>template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
>{
> typedef R type;
>};
>
>
>
>
>
>template< class Y, class T > inline void sp_assert_convertible() noexcept
>{
>
>
>
> typedef char tmp[ sp_convertible< Y, T >::value? 1: -1 ];
> (void)sizeof( tmp );
>
>
>
>
>
>
>
>}
>
>
>
>template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
>{
> boost::detail::shared_count( p ).swap( pn );
> boost::detail::sp_enable_shared_from_this( ppx, p, p );
>}
>
>
>
>template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
>{
> sp_assert_convertible< Y[], T[] >();
> boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
>}
>
>template< class T, std::size_t N, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
>{
> sp_assert_convertible< Y[N], T[N] >();
> boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
>}
>
>
>
>
>
>template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
>{
> boost::detail::sp_enable_shared_from_this( ppx, p, p );
>}
>
>
>
>template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
>{
> sp_assert_convertible< Y[], T[] >();
>}
>
>template< class T, std::size_t N, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
>{
> sp_assert_convertible< Y[N], T[N] >();
>}
>
>
>
>struct sp_internal_constructor_tag
>{
>};
>
>}
># 341 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class T> class shared_ptr
>{
>private:
>
>
> typedef shared_ptr<T> this_type;
>
>public:
>
> typedef typename boost::detail::sp_element< T >::type element_type;
>
> constexpr shared_ptr() noexcept : px( 0 ), pn()
> {
> }
>
>
>
> constexpr shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
> {
> }
>
>
>
> constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count const & pn_ ) noexcept : px( px_ ), pn( pn_ )
> {
> }
>
>
>
> constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count && pn_ ) noexcept : px( px_ ), pn( std::move( pn_ ) )
> {
> }
>
>
>
> template<class Y>
> explicit shared_ptr( Y * p ): px( p ), pn()
> {
> boost::detail::sp_pointer_construct( this, p, pn );
> }
>
>
>
>
>
>
>
> template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
> {
> boost::detail::sp_deleter_construct( this, p );
> }
>
>
>
> template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
> {
> }
>
>
>
>
>
> template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
> {
> boost::detail::sp_deleter_construct( this, p );
> }
>
>
>
> template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
> {
> }
># 422 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
> shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
> {
> }
>
>
>
> template<class Y>
> explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
>
> px = r.px;
> }
>
> template<class Y>
> shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
> noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
> {
> if( !pn.empty() )
> {
> px = r.px;
> }
> }
>
> template<class Y>
>
>
> shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px( r.px ), pn( r.pn )
> {
> boost::detail::sp_assert_convertible< Y, T >();
> }
>
>
> template< class Y >
> shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
> {
> }
>
>
>
> template<class Y>
> explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> Y * tmp = r.get();
> pn = boost::detail::shared_count( r );
>
> boost::detail::sp_deleter_construct( this, tmp );
> }
>
>
>
> template<class Y>
> shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> Y * tmp = r.get();
> pn = boost::detail::shared_count( r );
>
> boost::detail::sp_deleter_construct( this, tmp );
> }
># 515 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
> template< class Y, class D >
> shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> typename std::unique_ptr< Y, D >::pointer tmp = r.get();
>
> if( tmp != 0 )
> {
> pn = boost::detail::shared_count( r );
> boost::detail::sp_deleter_construct( this, tmp );
> }
> }
>
>
>
> template< class Y, class D >
> shared_ptr( boost::movelib::unique_ptr< Y, D > r ): px( r.get() ), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();
>
> if( tmp != 0 )
> {
> pn = boost::detail::shared_count( r );
> boost::detail::sp_deleter_construct( this, tmp );
> }
> }
>
>
>
> shared_ptr & operator=( shared_ptr const & r ) noexcept
> {
> this_type(r).swap(*this);
> return *this;
> }
>
>
>
> template<class Y>
> shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
> {
> this_type(r).swap(*this);
> return *this;
> }
>
>
>
>
>
> template<class Y>
> shared_ptr & operator=( std::auto_ptr<Y> & r )
> {
> this_type( r ).swap( *this );
> return *this;
> }
>
>
>
> template<class Y>
> shared_ptr & operator=( std::auto_ptr<Y> && r )
> {
> this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
> return *this;
> }
># 597 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
> template<class Y, class D>
> shared_ptr & operator=( std::unique_ptr<Y, D> && r )
> {
> this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
> return *this;
> }
>
>
>
> template<class Y, class D>
> shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r )
> {
>
>
> boost::detail::sp_assert_convertible< Y, T >();
>
> typename boost::movelib::unique_ptr< Y, D >::pointer p = r.get();
>
> shared_ptr tmp;
>
> if( p != 0 )
> {
> tmp.px = p;
> tmp.pn = boost::detail::shared_count( r );
>
> boost::detail::sp_deleter_construct( &tmp, p );
> }
>
> tmp.swap( *this );
>
> return *this;
> }
>
>
>
>
>
> shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
> {
> pn.swap( r.pn );
> r.px = 0;
> }
>
> template<class Y>
>
>
> shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
>
>
>
>
>
>
> noexcept : px( r.px ), pn()
> {
> boost::detail::sp_assert_convertible< Y, T >();
>
> pn.swap( r.pn );
> r.px = 0;
> }
>
> shared_ptr & operator=( shared_ptr && r ) noexcept
> {
> this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
> return *this;
> }
>
> template<class Y>
> shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
> {
> this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
> return *this;
> }
>
>
> template<class Y>
> shared_ptr( shared_ptr<Y> && r, element_type * p ) noexcept : px( p ), pn()
> {
> pn.swap( r.pn );
> r.px = 0;
> }
>
>
>
>
>
> shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
> {
> this_type().swap(*this);
> return *this;
> }
>
>
>
> void reset() noexcept
> {
> this_type().swap(*this);
> }
>
> template<class Y> void reset( Y * p )
> {
> (static_cast <bool> (p == 0 || p != px) ? void (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 698, __extension__ __PRETTY_FUNCTION__));
> this_type( p ).swap( *this );
> }
>
> template<class Y, class D> void reset( Y * p, D d )
> {
> this_type( p, d ).swap( *this );
> }
>
> template<class Y, class D, class A> void reset( Y * p, D d, A a )
> {
> this_type( p, d, a ).swap( *this );
> }
>
> template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) noexcept
> {
> this_type( r, p ).swap( *this );
> }
>
>
>
> template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) noexcept
> {
> this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
> }
>
>
>
> typename boost::detail::sp_dereference< T >::type operator* () const noexcept
> {
> (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 728, __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", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 734, __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", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 740, __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 )", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 741, __extension__ __PRETTY_FUNCTION__));
>
> return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
> }
>
> element_type * get() const noexcept
> {
> return px;
> }
>
>
># 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
># 12 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> explicit operator bool () const noexcept
> {
> return px != 0;
> }
># 61 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
> bool operator! () const noexcept
> {
> return px == 0;
> }
># 753 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
> bool unique() const noexcept
> {
> return pn.unique();
> }
>
> long use_count() const noexcept
> {
> return pn.use_count();
> }
>
> void swap( shared_ptr & other ) noexcept
> {
> std::swap(px, other.px);
> pn.swap(other.pn);
> }
>
> template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
> {
> return pn < rhs.pn;
> }
>
> template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
> {
> return pn < rhs.pn;
> }
>
> 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 const & b) noexcept
>{
> return a.get() == b.get();
>}
>
>template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr const & b) noexcept
>{
> return a.get() != b.get();
>}
># 846 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
>{
> return p.get() == 0;
>}
>
>template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
>{
> return p.get() != 0;
>}
>
>template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
>{
> return p.get() != 0;
>}
>
>
>
>template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr 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 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 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 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 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 && 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 && 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 && 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 && r ) noexcept
>{
> (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
>
> typedef typename shared_ptr<T>::element_type E;
>
> E * p = reinterpret_cast< E* >( r.get() );
> return shared_ptr<T>( std::move(r), p );
>}
>
>
>
>
>
>template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
>{
> return p.get();
>}
># 991 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
>
>{
> os << p.get();
> return os;
>}
># 1006 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
>namespace detail
>{
>
>template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
>{
> return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
>}
>
>template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept;
>template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept;
>
>class esft2_deleter_wrapper
>{
>private:
>
> shared_ptr<void const volatile> deleter_;
>
>public:
>
> esft2_deleter_wrapper()
> {
> }
>
> 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", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 1041, __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> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, int ) 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> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, int ) 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> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, int ) 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> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, int, int ) noexcept
>{
> return atomic_compare_exchange( p, v, w );
>}
>
>
>
>
>
>template< class T > struct hash;
>
>template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
>{
> return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
>}
>
>}
>
># 1 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 1 3 4
># 20 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 3 4
># 1 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 1 3 4
># 24 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
>namespace boost
>{
>
>namespace detail
>{
>
>class local_counted_base
>{
>private:
>
> local_counted_base & operator= ( local_counted_base const & );
>
>private:
>
>
> enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };
>
> count_type local_use_count_;
>
>public:
>
> constexpr local_counted_base() noexcept: local_use_count_( initial_ )
> {
> }
>
> constexpr local_counted_base( local_counted_base const & ) noexcept: local_use_count_( initial_ )
> {
> }
>
> virtual ~local_counted_base()
> {
> }
>
> virtual void local_cb_destroy() noexcept = 0;
>
> virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept = 0;
>
> void add_ref() noexcept
> {
># 73 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
> local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
> }
>
> void release() noexcept
> {
> local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );
>
> if( local_use_count_ == 0 )
> {
> local_cb_destroy();
> }
> }
>
> long local_use_count() const noexcept
> {
> return local_use_count_;
> }
>};
>
>class local_counted_impl: public local_counted_base
>{
>private:
>
> local_counted_impl( local_counted_impl const & );
>
>private:
>
> shared_count pn_;
>
>public:
>
> explicit local_counted_impl( shared_count const& pn ): pn_( pn )
> {
> }
>
>
>
> explicit local_counted_impl( shared_count && pn ): pn_( std::move(pn) )
> {
> }
>
>
>
> virtual void local_cb_destroy() noexcept
> {
> delete this;
> }
>
> virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept
> {
> return pn_;
> }
>};
>
>class local_counted_impl_em: public local_counted_base
>{
>public:
>
> shared_count pn_;
>
> virtual void local_cb_destroy() noexcept
> {
> shared_count().swap( pn_ );
> }
>
> virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept
> {
> return pn_;
> }
>};
>
>}
>
>}
># 21 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 2 3 4
>
>
>namespace boost
>{
>
>namespace detail
>{
>
>template<class D> class local_sp_deleter: public local_counted_impl_em
>{
>private:
>
> D d_;
>
>public:
>
> local_sp_deleter(): d_()
> {
> }
>
> explicit local_sp_deleter( D const& d ) noexcept: d_( d )
> {
> }
>
>
>
> explicit local_sp_deleter( D&& d ) noexcept: d_( std::move(d) )
> {
> }
>
>
>
> D& deleter()
> {
> return d_;
> }
>
> template<class Y> void operator()( Y* p ) noexcept
> {
> d_( p );
> }
>
>
>
> void operator()( boost::detail::sp_nullptr_t p ) noexcept
> {
> d_( p );
> }
>
>
>};
>
>template<> class local_sp_deleter<void>
>{
>};
>
>template<class D> D * get_local_deleter( local_sp_deleter<D> * p )
>{
> return &p->deleter();
>}
>
>inline void * get_local_deleter( local_sp_deleter<void> * )
>{
> return 0;
>}
>
>}
>
>}
># 1159 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
>
>namespace boost
>{
>
>namespace detail
>{
>
>template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept
>{
> return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
>}
>
>template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept
>{
> return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
>}
>
>}
>
>}
>
>
>#pragma GCC diagnostic pop
># 18 "/usr/include/boost/shared_ptr.hpp" 2 3 4
># 18 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4
>
>namespace boost {
>namespace date_time {
>
>
>
>
>
> template<class time_type>
> class second_clock
> {
> public:
> typedef typename time_type::date_type date_type;
> typedef typename time_type::time_duration_type time_duration_type;
>
> static time_type local_time()
> {
> ::std::time_t t;
> ::std::time(&t);
> ::std::tm curr, *curr_ptr;
>
> curr_ptr = c_time::localtime(&t, &curr);
> return create_time(curr_ptr);
> }
>
>
>
> static time_type universal_time()
> {
>
> ::std::time_t t;
> ::std::time(&t);
> ::std::tm curr, *curr_ptr;
>
> curr_ptr = c_time::gmtime(&t, &curr);
> return create_time(curr_ptr);
> }
>
> template<class time_zone_type>
> static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
> {
> typedef typename time_type::utc_time_type utc_time_type;
> utc_time_type utc_time = second_clock<utc_time_type>::universal_time();
> return time_type(utc_time, tz_ptr);
> }
>
>
> private:
> static time_type create_time(::std::tm* current)
> {
> date_type d(static_cast<unsigned short>(current->tm_year + 1900),
> static_cast<unsigned short>(current->tm_mon + 1),
> static_cast<unsigned short>(current->tm_mday));
> time_duration_type td(current->tm_hour,
> current->tm_min,
> current->tm_sec);
> return time_type(d,td);
> }
>
> };
>
>
>} }
># 11 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/microsec_time_clock.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 18 "/usr/include/boost/date_time/microsec_time_clock.hpp" 2 3 4
># 29 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
>namespace boost {
>namespace date_time {
># 40 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
> template<class time_type>
> class microsec_clock
> {
> private:
>
> typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);
>
> public:
> typedef typename time_type::date_type date_type;
> typedef typename time_type::time_duration_type time_duration_type;
> typedef typename time_duration_type::rep_type resolution_traits_type;
>
>
>
> template<class time_zone_type>
> static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
> {
> typedef typename time_type::utc_time_type utc_time_type;
> typedef second_clock<utc_time_type> second_clock;
>
>
> utc_time_type utc_time = second_clock::universal_time();
> time_duration_type utc_offset = second_clock::local_time() - utc_time;
>
>
> utc_time = microsec_clock<utc_time_type>::local_time() - utc_offset;
> return time_type(utc_time, tz_ptr);
> }
>
>
> static time_type local_time()
> {
> return create_time(&c_time::localtime);
> }
>
>
> static time_type universal_time()
> {
> return create_time(&c_time::gmtime);
> }
>
> private:
> static time_type create_time(time_converter converter)
> {
>
> timeval tv;
> gettimeofday(&tv, 0);
> std::time_t t = tv.tv_sec;
> boost::uint32_t sub_sec = tv.tv_usec;
># 110 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
> std::tm curr;
> std::tm* curr_ptr = converter(&t, &curr);
> date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
> static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
> static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));
>
>
>
>
>
> int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);
>
> time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
> static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
> static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
> sub_sec * adjust);
>
> return time_type(d,td);
> }
># 149 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
> };
>
>
>} }
># 12 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/posix_time/ptime.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/posix_time/ptime.hpp" 3 4
># 1 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
># 1 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
># 1 "/usr/include/c++/8/cstdlib" 1 3 4
># 39 "/usr/include/c++/8/cstdlib" 3 4
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 13 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
>
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/config/no_tr1/cmath.hpp" 1 3 4
># 21 "/usr/include/boost/config/no_tr1/cmath.hpp" 3 4
># 1 "/usr/include/c++/8/cmath" 1 3 4
># 39 "/usr/include/c++/8/cmath" 3 4
> 
># 40 "/usr/include/c++/8/cmath" 3
># 22 "/usr/include/boost/config/no_tr1/cmath.hpp" 2 3 4
># 16 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_duration.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/time_duration.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
># 1 "/usr/include/boost/operators.hpp" 1 3 4
># 116 "/usr/include/boost/operators.hpp" 3 4
>namespace boost
>{
>namespace operators_impl
>{
>namespace operators_detail
>{
>
>template <typename T> class empty_base {};
>
>}
>
>
>
>
>
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct less_than_comparable2 : B
>{
> friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
> friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
> friend bool operator>(const U& x, const T& y) { return y < x; }
> friend bool operator<(const U& x, const T& y) { return y > x; }
> friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
> friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
>};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct less_than_comparable1 : B
>{
> friend bool operator>(const T& x, const T& y) { return y < x; }
> friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
> friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
>};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct equality_comparable2 : B
>{
> friend bool operator==(const U& y, const T& x) { return x == y; }
> friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
> friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
>};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct equality_comparable1 : B
>{
> friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
>};
># 259 "/usr/include/boost/operators.hpp" 3 4
>template <class T, class U, class B = operators_detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = operators_detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = operators_detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = operators_detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };
>
>
>
>
>
>
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct incrementable : B
>{
> friend T operator++(T& x, int)
> {
> incrementable_type nrv(x);
> ++x;
> return nrv;
> }
>private:
> typedef T incrementable_type;
>};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct decrementable : B
>{
> friend T operator--(T& x, int)
> {
> decrementable_type nrv(x);
> --x;
> return nrv;
> }
>private:
> typedef T decrementable_type;
>};
>
>
>
>template <class T, class P, class B = operators_detail::empty_base<T> >
>struct dereferenceable : B
>{
> P operator->() const
> {
> return ::boost::addressof(*static_cast<const T&>(*this));
> }
>};
>
>template <class T, class I, class R, class B = operators_detail::empty_base<T> >
>struct indexable : B
>{
> R operator[](I n) const
> {
> return *(static_cast<const T&>(*this) + n);
> }
>};
># 357 "/usr/include/boost/operators.hpp" 3 4
>template <class T, class U, class B = operators_detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
>template <class T, class U, class B = operators_detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };
>
>
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct equivalent2 : B
>{
> friend bool operator==(const T& x, const U& y)
> {
> return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
> }
>};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct equivalent1 : B
>{
> friend bool operator==(const T&x, const T&y)
> {
> return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
> }
>};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct partially_ordered2 : B
>{
> friend bool operator<=(const T& x, const U& y)
> { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
> friend bool operator>=(const T& x, const U& y)
> { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
> friend bool operator>(const U& x, const T& y)
> { return y < x; }
> friend bool operator<(const U& x, const T& y)
> { return y > x; }
> friend bool operator<=(const U& x, const T& y)
> { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
> friend bool operator>=(const U& x, const T& y)
> { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
>};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct partially_ordered1 : B
>{
> friend bool operator>(const T& x, const T& y)
> { return y < x; }
> friend bool operator<=(const T& x, const T& y)
> { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
> friend bool operator>=(const T& x, const T& y)
> { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
>};
>
>
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct totally_ordered2
> : less_than_comparable2<T, U
> , equality_comparable2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct totally_ordered1
> : less_than_comparable1<T
> , equality_comparable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct additive2
> : addable2<T, U
> , subtractable2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct additive1
> : addable1<T
> , subtractable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct multiplicative2
> : multipliable2<T, U
> , dividable2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct multiplicative1
> : multipliable1<T
> , dividable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct integer_multiplicative2
> : multiplicative2<T, U
> , modable2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct integer_multiplicative1
> : multiplicative1<T
> , modable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct arithmetic2
> : additive2<T, U
> , multiplicative2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct arithmetic1
> : additive1<T
> , multiplicative1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct integer_arithmetic2
> : additive2<T, U
> , integer_multiplicative2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct integer_arithmetic1
> : additive1<T
> , integer_multiplicative1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct bitwise2
> : xorable2<T, U
> , andable2<T, U
> , orable2<T, U, B
> > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct bitwise1
> : xorable1<T
> , andable1<T
> , orable1<T, B
> > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct unit_steppable
> : incrementable<T
> , decrementable<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct shiftable2
> : left_shiftable2<T, U
> , right_shiftable2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct shiftable1
> : left_shiftable1<T
> , right_shiftable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct ring_operators2
> : additive2<T, U
> , subtractable2_left<T, U
> , multipliable2<T, U, B
> > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct ring_operators1
> : additive1<T
> , multipliable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct ordered_ring_operators2
> : ring_operators2<T, U
> , totally_ordered2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct ordered_ring_operators1
> : ring_operators1<T
> , totally_ordered1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct field_operators2
> : ring_operators2<T, U
> , dividable2<T, U
> , dividable2_left<T, U, B
> > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct field_operators1
> : ring_operators1<T
> , dividable1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct ordered_field_operators2
> : field_operators2<T, U
> , totally_ordered2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct ordered_field_operators1
> : field_operators1<T
> , totally_ordered1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct euclidian_ring_operators2
> : ring_operators2<T, U
> , dividable2<T, U
> , dividable2_left<T, U
> , modable2<T, U
> , modable2_left<T, U, B
> > > > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct euclidian_ring_operators1
> : ring_operators1<T
> , dividable1<T
> , modable1<T, B
> > > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct ordered_euclidian_ring_operators2
> : totally_ordered2<T, U
> , euclidian_ring_operators2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct ordered_euclidian_ring_operators1
> : totally_ordered1<T
> , euclidian_ring_operators1<T, B
> > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct euclidean_ring_operators2
> : ring_operators2<T, U
> , dividable2<T, U
> , dividable2_left<T, U
> , modable2<T, U
> , modable2_left<T, U, B
> > > > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct euclidean_ring_operators1
> : ring_operators1<T
> , dividable1<T
> , modable1<T, B
> > > > {};
>
>template <class T, class U, class B = operators_detail::empty_base<T> >
>struct ordered_euclidean_ring_operators2
> : totally_ordered2<T, U
> , euclidean_ring_operators2<T, U, B
> > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct ordered_euclidean_ring_operators1
> : totally_ordered1<T
> , euclidean_ring_operators1<T, B
> > > {};
>
>template <class T, class P, class B = operators_detail::empty_base<T> >
>struct input_iteratable
> : equality_comparable1<T
> , incrementable<T
> , dereferenceable<T, P, B
> > > > {};
>
>template <class T, class B = operators_detail::empty_base<T> >
>struct output_iteratable
> : incrementable<T, B
> > {};
>
>template <class T, class P, class B = operators_detail::empty_base<T> >
>struct forward_iteratable
> : input_iteratable<T, P, B
> > {};
>
>template <class T, class P, class B = operators_detail::empty_base<T> >
>struct bidirectional_iteratable
> : forward_iteratable<T, P
> , decrementable<T, B
> > > {};
>
>
>
>
>
>template <class T, class P, class D, class R, class B = operators_detail::empty_base<T> >
>struct random_access_iteratable
> : bidirectional_iteratable<T, P
> , less_than_comparable1<T
> , additive2<T, D
> , indexable<T, D, R, B
> > > > > {};
># 662 "/usr/include/boost/operators.hpp" 3 4
>namespace operators_detail
>{
>
>
>
>struct true_t {};
>struct false_t {};
>
>}
># 679 "/usr/include/boost/operators.hpp" 3 4
>template<class T> struct is_chained_base {
> typedef operators_detail::false_t value;
>};
># 757 "/usr/include/boost/operators.hpp" 3 4
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct less_than_comparable; template<class T, class U, class B> struct less_than_comparable<T, U, B, operators_detail::false_t> : less_than_comparable2<T, U, B> {}; template<class T, class U> struct less_than_comparable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, operators_detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< less_than_comparable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< less_than_comparable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< less_than_comparable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct equality_comparable; template<class T, class U, class B> struct equality_comparable<T, U, B, operators_detail::false_t> : equality_comparable2<T, U, B> {}; template<class T, class U> struct equality_comparable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, operators_detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< equality_comparable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< equality_comparable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< equality_comparable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct multipliable; template<class T, class U, class B> struct multipliable<T, U, B, operators_detail::false_t> : multipliable2<T, U, B> {}; template<class T, class U> struct multipliable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, operators_detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< multipliable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< multipliable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< multipliable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct addable; template<class T, class U, class B> struct addable<T, U, B, operators_detail::false_t> : addable2<T, U, B> {}; template<class T, class U> struct addable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, operators_detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< addable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< addable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< addable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct subtractable; template<class T, class U, class B> struct subtractable<T, U, B, operators_detail::false_t> : subtractable2<T, U, B> {}; template<class T, class U> struct subtractable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, operators_detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< subtractable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< subtractable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< subtractable1<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class B> struct is_chained_base< subtractable2_left<T, U, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct dividable; template<class T, class U, class B> struct dividable<T, U, B, operators_detail::false_t> : dividable2<T, U, B> {}; template<class T, class U> struct dividable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, operators_detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< dividable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< dividable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< dividable1<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class B> struct is_chained_base< dividable2_left<T, U, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct modable; template<class T, class U, class B> struct modable<T, U, B, operators_detail::false_t> : modable2<T, U, B> {}; template<class T, class U> struct modable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, operators_detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< modable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< modable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< modable1<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class B> struct is_chained_base< modable2_left<T, U, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct xorable; template<class T, class U, class B> struct xorable<T, U, B, operators_detail::false_t> : xorable2<T, U, B> {}; template<class T, class U> struct xorable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, operators_detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< xorable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< xorable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< xorable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct andable; template<class T, class U, class B> struct andable<T, U, B, operators_detail::false_t> : andable2<T, U, B> {}; template<class T, class U> struct andable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, operators_detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< andable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< andable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< andable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct orable; template<class T, class U, class B> struct orable<T, U, B, operators_detail::false_t> : orable2<T, U, B> {}; template<class T, class U> struct orable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, operators_detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< orable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< orable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< orable1<T, B> > { typedef operators_detail::true_t value; };
>
>template<class T, class B> struct is_chained_base< incrementable<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class B> struct is_chained_base< decrementable<T, B> > { typedef operators_detail::true_t value; };
>
>template<class T, class U, class B> struct is_chained_base< dereferenceable<T, U, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class V, class B> struct is_chained_base< indexable<T, U, V, B> > { typedef operators_detail::true_t value; };
>
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct left_shiftable; template<class T, class U, class B> struct left_shiftable<T, U, B, operators_detail::false_t> : left_shiftable2<T, U, B> {}; template<class T, class U> struct left_shiftable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, operators_detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< left_shiftable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< left_shiftable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< left_shiftable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct right_shiftable; template<class T, class U, class B> struct right_shiftable<T, U, B, operators_detail::false_t> : right_shiftable2<T, U, B> {}; template<class T, class U> struct right_shiftable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, operators_detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< right_shiftable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< right_shiftable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< right_shiftable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct equivalent; template<class T, class U, class B> struct equivalent<T, U, B, operators_detail::false_t> : equivalent2<T, U, B> {}; template<class T, class U> struct equivalent<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, operators_detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< equivalent<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< equivalent2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< equivalent1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct partially_ordered; template<class T, class U, class B> struct partially_ordered<T, U, B, operators_detail::false_t> : partially_ordered2<T, U, B> {}; template<class T, class U> struct partially_ordered<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, operators_detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< partially_ordered<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< partially_ordered2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< partially_ordered1<T, B> > { typedef operators_detail::true_t value; };
>
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct totally_ordered; template<class T, class U, class B> struct totally_ordered<T, U, B, operators_detail::false_t> : totally_ordered2<T, U, B> {}; template<class T, class U> struct totally_ordered<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, operators_detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< totally_ordered<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< totally_ordered2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< totally_ordered1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct additive; template<class T, class U, class B> struct additive<T, U, B, operators_detail::false_t> : additive2<T, U, B> {}; template<class T, class U> struct additive<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, operators_detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< additive<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< additive2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< additive1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct multiplicative; template<class T, class U, class B> struct multiplicative<T, U, B, operators_detail::false_t> : multiplicative2<T, U, B> {}; template<class T, class U> struct multiplicative<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, operators_detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< multiplicative<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< multiplicative2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< multiplicative1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct integer_multiplicative; template<class T, class U, class B> struct integer_multiplicative<T, U, B, operators_detail::false_t> : integer_multiplicative2<T, U, B> {}; template<class T, class U> struct integer_multiplicative<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, operators_detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< integer_multiplicative<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< integer_multiplicative2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< integer_multiplicative1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct arithmetic; template<class T, class U, class B> struct arithmetic<T, U, B, operators_detail::false_t> : arithmetic2<T, U, B> {}; template<class T, class U> struct arithmetic<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, operators_detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< arithmetic<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< arithmetic2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< arithmetic1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct integer_arithmetic; template<class T, class U, class B> struct integer_arithmetic<T, U, B, operators_detail::false_t> : integer_arithmetic2<T, U, B> {}; template<class T, class U> struct integer_arithmetic<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, operators_detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< integer_arithmetic<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< integer_arithmetic2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< integer_arithmetic1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct bitwise; template<class T, class U, class B> struct bitwise<T, U, B, operators_detail::false_t> : bitwise2<T, U, B> {}; template<class T, class U> struct bitwise<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, operators_detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< bitwise<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< bitwise2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< bitwise1<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class B> struct is_chained_base< unit_steppable<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct shiftable; template<class T, class U, class B> struct shiftable<T, U, B, operators_detail::false_t> : shiftable2<T, U, B> {}; template<class T, class U> struct shiftable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, operators_detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< shiftable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< shiftable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< shiftable1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct ring_operators; template<class T, class U, class B> struct ring_operators<T, U, B, operators_detail::false_t> : ring_operators2<T, U, B> {}; template<class T, class U> struct ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, operators_detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ring_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_ring_operators; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, operators_detail::false_t> : ordered_ring_operators2<T, U, B> {}; template<class T, class U> struct ordered_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, operators_detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct field_operators; template<class T, class U, class B> struct field_operators<T, U, B, operators_detail::false_t> : field_operators2<T, U, B> {}; template<class T, class U> struct field_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, operators_detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< field_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< field_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< field_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_field_operators; template<class T, class U, class B> struct ordered_field_operators<T, U, B, operators_detail::false_t> : ordered_field_operators2<T, U, B> {}; template<class T, class U> struct ordered_field_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, operators_detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_field_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_field_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_field_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct euclidian_ring_operators; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, operators_detail::false_t> : euclidian_ring_operators2<T, U, B> {}; template<class T, class U> struct euclidian_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, operators_detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< euclidian_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< euclidian_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< euclidian_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_euclidian_ring_operators; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, operators_detail::false_t> : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U> struct ordered_euclidian_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, operators_detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_euclidian_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_euclidian_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_euclidian_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct euclidean_ring_operators; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, operators_detail::false_t> : euclidean_ring_operators2<T, U, B> {}; template<class T, class U> struct euclidean_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, operators_detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< euclidean_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< euclidean_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< euclidean_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
>template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base::value > struct ordered_euclidean_ring_operators; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, operators_detail::false_t> : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U> struct ordered_euclidean_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, operators_detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_euclidean_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_euclidean_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_euclidean_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class B> struct is_chained_base< input_iteratable<T, U, B> > { typedef operators_detail::true_t value; };
>template<class T, class B> struct is_chained_base< output_iteratable<T, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class B> struct is_chained_base< forward_iteratable<T, U, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class B> struct is_chained_base< bidirectional_iteratable<T, U, B> > { typedef operators_detail::true_t value; };
>template<class T, class U, class V, class W, class B> struct is_chained_base< random_access_iteratable<T, U, V, W, B> > { typedef operators_detail::true_t value; };
>
>
>
>
>
>
>
>template <class T, class U>
>struct operators2
> : totally_ordered2<T,U
> , integer_arithmetic2<T,U
> , bitwise2<T,U
> > > > {};
>
>template <class T, class U = T>
>struct operators : operators2<T, U> {};
>
>template <class T> struct operators<T, T>
> : totally_ordered<T
> , integer_arithmetic<T
> , bitwise<T
> , unit_steppable<T
> > > > > {};
>
>
>
>
>
>template <class Category,
> class T,
> class Distance = std::ptrdiff_t,
> class Pointer = T*,
> class Reference = T&>
>struct iterator_helper
>{
> typedef Category iterator_category;
> typedef T value_type;
> typedef Distance difference_type;
> typedef Pointer pointer;
> typedef Reference reference;
>};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V const *,
> class R = V const &>
>struct input_iterator_helper
> : input_iteratable<T, P
> , iterator_helper<std::input_iterator_tag, V, D, P, R
> > > {};
>
>template<class T>
>struct output_iterator_helper
> : output_iteratable<T
> , iterator_helper<std::output_iterator_tag, void, void, void, void
> > >
>{
> T& operator*() { return static_cast<T&>(*this); }
> T& operator++() { return static_cast<T&>(*this); }
>};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V*,
> class R = V&>
>struct forward_iterator_helper
> : forward_iteratable<T, P
> , iterator_helper<std::forward_iterator_tag, V, D, P, R
> > > {};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V*,
> class R = V&>
>struct bidirectional_iterator_helper
> : bidirectional_iteratable<T, P
> , iterator_helper<std::bidirectional_iterator_tag, V, D, P, R
> > > {};
>
>template <class T,
> class V,
> class D = std::ptrdiff_t,
> class P = V*,
> class R = V&>
>struct random_access_iterator_helper
> : random_access_iteratable<T, P, D, R
> , iterator_helper<std::random_access_iterator_tag, V, D, P, R
> > >
>{
> friend D requires_difference_operator(const T& x, const T& y) {
> return x - y;
> }
>};
>
>}
>using namespace operators_impl;
>
>}
># 14 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
># 1 "/usr/include/boost/static_assert.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_defs.hpp" 1 3 4
># 19 "/usr/include/boost/date_time/time_defs.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> enum time_resolutions {
> sec,
> tenth,
> hundreth,
> hundredth = hundreth,
> milli,
> ten_thousandth,
> micro,
> nano,
> NumResolutions
> };
>
>
> enum dst_flags {not_dst, is_dst, calculate};
>
>
>} }
># 16 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/special_defs.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/special_defs.hpp" 3 4
>namespace boost {
>namespace date_time {
>
> enum special_values {not_a_date_time,
> neg_infin, pos_infin,
> min_date_time, max_date_time,
> not_special, NumSpecialValues};
>
>
>} }
># 17 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
>
>
>namespace boost {
>namespace date_time {
># 33 "/usr/include/boost/date_time/time_duration.hpp" 3 4
> template<class T, typename rep_type>
> class __attribute__((__visibility__("default"))) time_duration : private
> boost::less_than_comparable<T
> , boost::equality_comparable<T
> > >
>
>
>
>
>
> {
> public:
>
> typedef void _is_boost_date_time_duration;
> typedef T duration_type;
> typedef rep_type traits_type;
> typedef typename rep_type::day_type day_type;
> typedef typename rep_type::hour_type hour_type;
> typedef typename rep_type::min_type min_type;
> typedef typename rep_type::sec_type sec_type;
> typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
> typedef typename rep_type::tick_type tick_type;
> typedef typename rep_type::impl_type impl_type;
>
> time_duration() : ticks_(0) {}
> time_duration(hour_type hours_in,
> min_type minutes_in,
> sec_type seconds_in=0,
> fractional_seconds_type frac_sec_in = 0) :
> ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
> {}
>
>
> time_duration(const time_duration<T, rep_type>& other)
> : ticks_(other.ticks_)
> {}
>
> time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
> {}
>
> static duration_type unit()
> {
> return duration_type(0,0,0,1);
> }
>
> static tick_type ticks_per_second()
> {
> return rep_type::res_adjust();
> }
>
> static time_resolutions resolution()
> {
> return rep_type::resolution();
> }
>
> hour_type hours() const
> {
> return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
> }
>
> min_type minutes() const
> {
> return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
> }
>
> sec_type seconds() const
> {
> return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
> }
>
> sec_type total_seconds() const
> {
> return static_cast<sec_type>(ticks() / ticks_per_second());
> }
>
> tick_type total_milliseconds() const
> {
> if (ticks_per_second() < 1000) {
> return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
> }
> return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
> }
>
> tick_type total_nanoseconds() const
> {
> if (ticks_per_second() < 1000000000) {
> return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
> }
> return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
> }
>
> tick_type total_microseconds() const
> {
> if (ticks_per_second() < 1000000) {
> return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
> }
> return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
> }
>
> fractional_seconds_type fractional_seconds() const
> {
> return (ticks() % ticks_per_second());
> }
>
> static unsigned short num_fractional_digits()
> {
> return rep_type::num_fractional_digits();
> }
> duration_type invert_sign() const
> {
> return duration_type(ticks_ * (-1));
> }
> bool is_negative() const
> {
> return ticks_ < 0;
> }
> bool operator<(const time_duration& rhs) const
> {
> return ticks_ < rhs.ticks_;
> }
> bool operator==(const time_duration& rhs) const
> {
> return ticks_ == rhs.ticks_;
> }
>
> duration_type operator-()const
> {
> return duration_type(ticks_ * (-1));
> }
> duration_type operator-(const duration_type& d) const
> {
> return duration_type(ticks_ - d.ticks_);
> }
> duration_type operator+(const duration_type& d) const
> {
> return duration_type(ticks_ + d.ticks_);
> }
> duration_type operator/(int divisor) const
> {
> return duration_type(ticks_ / divisor);
> }
> duration_type operator-=(const duration_type& d)
> {
> ticks_ = ticks_ - d.ticks_;
> return duration_type(ticks_);
> }
> duration_type operator+=(const duration_type& d)
> {
> ticks_ = ticks_ + d.ticks_;
> return duration_type(ticks_);
> }
>
> duration_type operator/=(int divisor)
> {
> ticks_ = ticks_ / divisor;
> return duration_type(ticks_);
> }
>
> duration_type operator*(int rhs) const
> {
> return duration_type(ticks_ * rhs);
> }
> duration_type operator*=(int divisor)
> {
> ticks_ = ticks_ * divisor;
> return duration_type(ticks_);
> }
> tick_type ticks() const
> {
> return traits_type::as_number(ticks_);
> }
>
>
> bool is_special()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_special();
> }
> else{
> return false;
> }
> }
>
> bool is_pos_infinity()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_pos_infinity();
> }
> else{
> return false;
> }
> }
>
> bool is_neg_infinity()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_neg_infinity();
> }
> else{
> return false;
> }
> }
>
> bool is_not_a_date_time()const
> {
> if(traits_type::is_adapted())
> {
> return ticks_.is_nan();
> }
> else{
> return false;
> }
> }
>
>
> impl_type get_rep()const
> {
> return ticks_;
> }
>
> protected:
> explicit time_duration(impl_type in) : ticks_(in) {}
> impl_type ticks_;
> };
>
>
>
>
>
>
>
> template<class base_duration, boost::int64_t frac_of_second>
> class __attribute__((__visibility__("default"))) subsecond_duration : public base_duration
> {
> public:
> typedef typename base_duration::impl_type impl_type;
> typedef typename base_duration::traits_type traits_type;
>
> private:
>
> static_assert((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0, "The base duration resolution must be a multiple of the subsecond duration resolution")
> ;
> static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);
>
> public:
> explicit subsecond_duration(boost::int64_t ss) :
> base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
> {
> }
> };
>
>
>
>} }
># 17 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_resolution_traits.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/time_resolution_traits.hpp" 3 4
># 1 "/usr/include/c++/8/ctime" 1 3 4
># 39 "/usr/include/c++/8/ctime" 3 4
> 
># 40 "/usr/include/c++/8/ctime" 3
># 13 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/int_adapter.hpp" 1 3 4
># 21 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
>namespace boost {
>namespace date_time {
># 39 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
>template<typename int_type_>
>class int_adapter {
>public:
> typedef int_type_ int_type;
> int_adapter(int_type v) :
> value_(v)
> {}
> static bool has_infinity()
> {
> return true;
> }
> static const int_adapter pos_infinity()
> {
> return (::std::numeric_limits<int_type>::max)();
> }
> static const int_adapter neg_infinity()
> {
> return (::std::numeric_limits<int_type>::min)();
> }
> static const int_adapter not_a_number()
> {
> return (::std::numeric_limits<int_type>::max)()-1;
> }
> static int_adapter max ()
> {
> return (::std::numeric_limits<int_type>::max)()-2;
> }
> static int_adapter min ()
> {
> return (::std::numeric_limits<int_type>::min)()+1;
> }
> static int_adapter from_special(special_values sv)
> {
> switch (sv) {
> case not_a_date_time: return not_a_number();
> case neg_infin: return neg_infinity();
> case pos_infin: return pos_infinity();
> case max_date_time: return (max)();
> case min_date_time: return (min)();
> default: return not_a_number();
> }
> }
> static bool is_inf(int_type v)
> {
> return (v == neg_infinity().as_number() ||
> v == pos_infinity().as_number());
> }
> static bool is_neg_inf(int_type v)
> {
> return (v == neg_infinity().as_number());
> }
> static bool is_pos_inf(int_type v)
> {
> return (v == pos_infinity().as_number());
> }
> static bool is_not_a_number(int_type v)
> {
> return (v == not_a_number().as_number());
> }
>
> static special_values to_special(int_type v)
> {
> if (is_not_a_number(v)) return not_a_date_time;
> if (is_neg_inf(v)) return neg_infin;
> if (is_pos_inf(v)) return pos_infin;
> return not_special;
> }
>
>
> static int_type maxcount()
> {
> return (::std::numeric_limits<int_type>::max)()-3;
> }
> bool is_infinity() const
> {
> return (value_ == neg_infinity().as_number() ||
> value_ == pos_infinity().as_number());
> }
> bool is_pos_infinity()const
> {
> return(value_ == pos_infinity().as_number());
> }
> bool is_neg_infinity()const
> {
> return(value_ == neg_infinity().as_number());
> }
> bool is_nan() const
> {
> return (value_ == not_a_number().as_number());
> }
> bool is_special() const
> {
> return(is_infinity() || is_nan());
> }
> bool operator==(const int_adapter& rhs) const
> {
> return (compare(rhs) == 0);
> }
> bool operator==(const int& rhs) const
> {
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(!is_signed)
> {
> if(is_neg_inf(value_) && rhs == 0)
> {
> return false;
> }
> }
> return (compare(rhs) == 0);
> }
> bool operator!=(const int_adapter& rhs) const
> {
> return (compare(rhs) != 0);
> }
> bool operator!=(const int& rhs) const
> {
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(!is_signed)
> {
> if(is_neg_inf(value_) && rhs == 0)
> {
> return true;
> }
> }
> return (compare(rhs) != 0);
> }
> bool operator<(const int_adapter& rhs) const
> {
> return (compare(rhs) == -1);
> }
> bool operator<(const int& rhs) const
> {
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(!is_signed)
> {
> if(is_neg_inf(value_) && rhs == 0)
> {
> return true;
> }
> }
> return (compare(rhs) == -1);
> }
> bool operator>(const int_adapter& rhs) const
> {
> return (compare(rhs) == 1);
> }
> int_type as_number() const
> {
> return value_;
> }
>
> special_values as_special() const
> {
> return int_adapter::to_special(value_);
> }
># 205 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
> template<class rhs_type>
> inline
> int_adapter operator+(const int_adapter<rhs_type>& rhs) const
> {
> if(is_special() || rhs.is_special())
> {
> if (is_nan() || rhs.is_nan())
> {
> return int_adapter::not_a_number();
> }
> if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ||
> (is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) )
> {
> return int_adapter::not_a_number();
> }
> if (is_infinity())
> {
> return *this;
> }
> if (rhs.is_pos_inf(rhs.as_number()))
> {
> return int_adapter::pos_infinity();
> }
> if (rhs.is_neg_inf(rhs.as_number()))
> {
> return int_adapter::neg_infinity();
> }
> }
> return int_adapter<int_type>(value_ + static_cast<int_type>(rhs.as_number()));
> }
>
> int_adapter operator+(const int_type rhs) const
> {
> if(is_special())
> {
> if (is_nan())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if (is_infinity())
> {
> return *this;
> }
> }
> return int_adapter<int_type>(value_ + rhs);
> }
>
>
>
> template<class rhs_type>
> inline
> int_adapter operator-(const int_adapter<rhs_type>& rhs)const
> {
> if(is_special() || rhs.is_special())
> {
> if (is_nan() || rhs.is_nan())
> {
> return int_adapter::not_a_number();
> }
> if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ||
> (is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) )
> {
> return int_adapter::not_a_number();
> }
> if (is_infinity())
> {
> return *this;
> }
> if (rhs.is_pos_inf(rhs.as_number()))
> {
> return int_adapter::neg_infinity();
> }
> if (rhs.is_neg_inf(rhs.as_number()))
> {
> return int_adapter::pos_infinity();
> }
> }
> return int_adapter<int_type>(value_ - static_cast<int_type>(rhs.as_number()));
> }
> int_adapter operator-(const int_type rhs) const
> {
> if(is_special())
> {
> if (is_nan())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if (is_infinity())
> {
> return *this;
> }
> }
> return int_adapter<int_type>(value_ - rhs);
> }
>
>
> int_adapter operator*(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ * rhs.value_);
> }
>
>
> int_adapter operator*(const int rhs) const
> {
> if(is_special())
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ * rhs);
> }
>
>
> int_adapter operator/(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> if(is_infinity() && rhs.is_infinity())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if(rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> else {
> return int_adapter<int_type>(value_ / rhs.value_);
> }
> }
> return int_adapter<int_type>(value_ / rhs.value_);
> }
>
>
> int_adapter operator/(const int rhs) const
> {
> if(is_special() && rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ / rhs);
> }
>
>
> int_adapter operator%(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> if(is_infinity() && rhs.is_infinity())
> {
> return int_adapter<int_type>(not_a_number());
> }
> if(rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> else {
> return int_adapter<int_type>(value_ % rhs.value_);
> }
> }
> return int_adapter<int_type>(value_ % rhs.value_);
> }
>
>
> int_adapter operator%(const int rhs) const
> {
> if(is_special() && rhs != 0)
> {
> return mult_div_specials(rhs);
> }
> return int_adapter<int_type>(value_ % rhs);
> }
>private:
> int_type value_;
>
>
> int compare(const int_adapter& rhs)const
> {
> if(this->is_special() || rhs.is_special())
> {
> if(this->is_nan() || rhs.is_nan()) {
> if(this->is_nan() && rhs.is_nan()) {
> return 0;
> }
> else {
> return 2;
> }
> }
> if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) ||
> (is_pos_inf(rhs.value_) && !is_pos_inf(value_)) )
> {
> return -1;
> }
> if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) ||
> (is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) {
> return 1;
> }
> }
> if(value_ < rhs.value_) return -1;
> if(value_ > rhs.value_) return 1;
>
> return 0;
> }
>
>
>
>
>
> int_adapter mult_div_specials(const int_adapter& rhs)const
> {
> int min_value;
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(is_signed) {
> min_value = 0;
> }
> else {
> min_value = 1;
> }
> if(this->is_nan() || rhs.is_nan()) {
> return int_adapter<int_type>(not_a_number());
> }
> if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
> return int_adapter<int_type>(pos_infinity());
> }
> if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) {
> return int_adapter<int_type>(neg_infinity());
> }
>
> return int_adapter<int_type>(not_a_number());
> }
>
>
>
>
>
>
> int_adapter mult_div_specials(const int& rhs) const
> {
> int min_value;
>
> bool is_signed = std::numeric_limits<int_type>::is_signed;
> if(is_signed) {
> min_value = 0;
> }
> else {
> min_value = 1;
> }
> if(this->is_nan()) {
> return int_adapter<int_type>(not_a_number());
> }
> if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
> return int_adapter<int_type>(pos_infinity());
> }
> if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) {
> return int_adapter<int_type>(neg_infinity());
> }
>
> return int_adapter<int_type>(not_a_number());
> }
>
>};
>
>
>
>
>
>
> template<class charT, class traits, typename int_type>
> inline
> std::basic_ostream<charT, traits>&
> operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
> {
> if(ia.is_special()) {
>
> switch(ia.as_special())
> {
> case not_a_date_time:
> os << "not-a-number";
> break;
> case pos_infin:
> os << "+infinity";
> break;
> case neg_infin:
> os << "-infinity";
> break;
> default:
> os << "";
> }
> }
> else {
> os << ia.as_number();
> }
> return os;
> }
>
>
>
>} }
># 16 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
>
>
>namespace boost {
>namespace date_time {
>
>
> template <typename T>
>
>
> inline T absolute_value(T x)
> {
> return x < 0 ? -x : x;
> }
>
>
> struct time_resolution_traits_bi32_impl {
> typedef boost::int32_t int_type;
> typedef boost::int32_t impl_type;
> static int_type as_number(impl_type i){ return i;}
>
> static bool is_adapted() { return false;}
> };
>
> struct time_resolution_traits_adapted32_impl {
> typedef boost::int32_t int_type;
> typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
> static int_type as_number(impl_type i){ return i.as_number();}
>
> static bool is_adapted() { return true;}
> };
>
> struct time_resolution_traits_bi64_impl {
> typedef boost::int64_t int_type;
> typedef boost::int64_t impl_type;
> static int_type as_number(impl_type i){ return i;}
>
> static bool is_adapted() { return false;}
> };
>
> struct time_resolution_traits_adapted64_impl {
> typedef boost::int64_t int_type;
> typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
> static int_type as_number(impl_type i){ return i.as_number();}
>
> static bool is_adapted() { return true;}
> };
>
> template<typename frac_sec_type,
> time_resolutions res,
>
>
>
> typename frac_sec_type::int_type resolution_adjust,
>
> unsigned short frac_digits,
> typename var_type = std::time_t >
> class time_resolution_traits {
> public:
> typedef typename frac_sec_type::int_type fractional_seconds_type;
> typedef typename frac_sec_type::int_type tick_type;
> typedef typename frac_sec_type::impl_type impl_type;
> typedef var_type day_type;
> typedef var_type hour_type;
> typedef var_type min_type;
> typedef var_type sec_type;
>
>
> static fractional_seconds_type as_number(impl_type i)
> {
> return frac_sec_type::as_number(i);
> }
> static bool is_adapted()
> {
> return frac_sec_type::is_adapted();
> }
>
>
>
>
>
> static const fractional_seconds_type ticks_per_second = resolution_adjust;
>
>
> static time_resolutions resolution()
> {
> return res;
> }
> static unsigned short num_fractional_digits()
> {
> return frac_digits;
> }
> static fractional_seconds_type res_adjust()
> {
> return resolution_adjust;
> }
>
> static tick_type to_tick_count(hour_type hours,
> min_type minutes,
> sec_type seconds,
> fractional_seconds_type fs)
> {
> if(hours < 0 || minutes < 0 || seconds < 0 || fs < 0)
> {
> hours = absolute_value(hours);
> minutes = absolute_value(minutes);
> seconds = absolute_value(seconds);
> fs = absolute_value(fs);
> return static_cast<tick_type>(((((fractional_seconds_type(hours)*3600)
> + (fractional_seconds_type(minutes)*60)
> + seconds)*res_adjust()) + fs) * -1);
> }
>
> return static_cast<tick_type>((((fractional_seconds_type(hours)*3600)
> + (fractional_seconds_type(minutes)*60)
> + seconds)*res_adjust()) + fs);
> }
>
> };
>
> typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
> typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
> typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;
>
>
>} }
># 18 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 3 4
># 1 "/usr/include/boost/date_time/date.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/date.hpp" 3 4
># 1 "/usr/include/boost/date_time/year_month_day.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/year_month_day.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> template<typename YearType, typename MonthType, typename DayType>
> struct __attribute__((__visibility__("default"))) year_month_day_base {
> year_month_day_base(YearType year,
> MonthType month,
> DayType day);
> YearType year;
> MonthType month;
> DayType day;
> typedef YearType year_type;
> typedef MonthType month_type;
> typedef DayType day_type;
> };
>
>
>
> template<typename YearType, typename MonthType, typename DayType>
> inline
> year_month_day_base<YearType,MonthType,DayType>::year_month_day_base(YearType y,
> MonthType m,
> DayType d) :
> year(y),
> month(m),
> day(d)
> {}
>
>} }
># 15 "/usr/include/boost/date_time/date.hpp" 2 3 4
>
>
>namespace boost {
>namespace date_time {
># 53 "/usr/include/boost/date_time/date.hpp" 3 4
> template<class T, class calendar, class duration_type_>
> class __attribute__((__visibility__("default"))) date : private
> boost::less_than_comparable<T
> , boost::equality_comparable<T
> > >
> {
> public:
> typedef T date_type;
> typedef calendar calendar_type;
> typedef typename calendar::date_traits_type traits_type;
> typedef duration_type_ duration_type;
> typedef typename calendar::year_type year_type;
> typedef typename calendar::month_type month_type;
> typedef typename calendar::day_type day_type;
> typedef typename calendar::ymd_type ymd_type;
> typedef typename calendar::date_rep_type date_rep_type;
> typedef typename calendar::date_int_type date_int_type;
> typedef typename calendar::day_of_week_type day_of_week_type;
> date(year_type y, month_type m, day_type d)
> : days_(calendar::day_number(ymd_type(y, m, d)))
> {}
> date(const ymd_type& ymd)
> : days_(calendar::day_number(ymd))
> {}
>
> year_type year() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return ymd.year;
> }
> month_type month() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return ymd.month;
> }
> day_type day() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return ymd.day;
> }
> day_of_week_type day_of_week() const
> {
> ymd_type ymd = calendar::from_day_number(days_);
> return calendar::day_of_week(ymd);
> }
> ymd_type year_month_day() const
> {
> return calendar::from_day_number(days_);
> }
> bool operator<(const date_type& rhs) const
> {
> return days_ < rhs.days_;
> }
> bool operator==(const date_type& rhs) const
> {
> return days_ == rhs.days_;
> }
>
> bool is_special()const
> {
> return(is_not_a_date() || is_infinity());
> }
>
> bool is_not_a_date() const
> {
> return traits_type::is_not_a_number(days_);
> }
>
> bool is_infinity() const
> {
> return traits_type::is_inf(days_);
> }
>
> bool is_pos_infinity() const
> {
> return traits_type::is_pos_inf(days_);
> }
>
> bool is_neg_infinity() const
> {
> return traits_type::is_neg_inf(days_);
> }
>
> special_values as_special() const
> {
> return traits_type::to_special(days_);
> }
> duration_type operator-(const date_type& d) const
> {
> if (!this->is_special() && !d.is_special())
> {
>
>
> typedef typename duration_type::duration_rep_type duration_rep_type;
> return duration_type(static_cast< duration_rep_type >(days_) - static_cast< duration_rep_type >(d.days_));
> }
> else
> {
>
> date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_);
> return duration_type(val.as_special());
> }
> }
>
> date_type operator-(const duration_type& dd) const
> {
> if(dd.is_special())
> {
> return date_type(date_rep_type(days_) - dd.get_rep());
> }
> return date_type(date_rep_type(days_) - static_cast<date_int_type>(dd.days()));
> }
> date_type operator-=(const duration_type& dd)
> {
> *this = *this - dd;
> return date_type(days_);
> }
> date_rep_type day_count() const
> {
> return days_;
> }
>
> date_type operator+(const duration_type& dd) const
> {
> if(dd.is_special())
> {
> return date_type(date_rep_type(days_) + dd.get_rep());
> }
> return date_type(date_rep_type(days_) + static_cast<date_int_type>(dd.days()));
> }
> date_type operator+=(const duration_type& dd)
> {
> *this = *this + dd;
> return date_type(days_);
> }
>
>
> protected:
>
>
>
>
> explicit date(date_int_type days) : days_(days) {}
> explicit date(date_rep_type days) : days_(days.as_number()) {}
> date_int_type days_;
>
> };
>
>
>
>
>} }
># 18 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/period.hpp" 1 3 4
># 24 "/usr/include/boost/date_time/period.hpp" 3 4
>namespace boost {
>namespace date_time {
># 51 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> class __attribute__((__visibility__("default"))) period : private
> boost::less_than_comparable<period<point_rep, duration_rep>
> , boost::equality_comparable< period<point_rep, duration_rep>
> > >
> {
> public:
> typedef point_rep point_type;
> typedef duration_rep duration_type;
>
> period(point_rep first_point, point_rep end_point);
> period(point_rep first_point, duration_rep len);
> point_rep begin() const;
> point_rep end() const;
> point_rep last() const;
> duration_rep length() const;
> bool is_null() const;
> bool operator==(const period& rhs) const;
> bool operator<(const period& rhs) const;
> void shift(const duration_rep& d);
> void expand(const duration_rep& d);
> bool contains(const point_rep& point) const;
> bool contains(const period& other) const;
> bool intersects(const period& other) const;
> bool is_adjacent(const period& other) const;
> bool is_before(const point_rep& point) const;
> bool is_after(const point_rep& point) const;
> period intersection(const period& other) const;
> period merge(const period& other) const;
> period span(const period& other) const;
> private:
> point_rep begin_;
> point_rep last_;
> };
>
>
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>::period(point_rep first_point,
> point_rep end_point) :
> begin_(first_point),
> last_(end_point - duration_rep::unit())
> {}
>
>
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>::period(point_rep first_point, duration_rep len) :
> begin_(first_point),
> last_(first_point + len-duration_rep::unit())
> { }
>
>
>
> template<class point_rep, class duration_rep>
> inline
> point_rep period<point_rep,duration_rep>::begin() const
> {
> return begin_;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> point_rep period<point_rep,duration_rep>::end() const
> {
> return last_ + duration_rep::unit();
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> point_rep period<point_rep,duration_rep>::last() const
> {
> return last_;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::is_null() const
> {
> return end() <= begin_;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> duration_rep period<point_rep,duration_rep>::length() const
> {
> if(last_ < begin_){
> return last_+duration_rep::unit() - begin_;
> }
> else{
> return end() - begin_;
> }
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::operator==(const period& rhs) const
> {
> return ((begin_ == rhs.begin_) &&
> (last_ == rhs.last_));
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::operator<(const period& rhs) const
> {
> return (last_ < rhs.begin_);
> }
>
>
>
> template<class point_rep, class duration_rep>
> inline
> void period<point_rep,duration_rep>::shift(const duration_rep& d)
> {
> begin_ = begin_ + d;
> last_ = last_ + d;
> }
># 199 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> void period<point_rep,duration_rep>::expand(const duration_rep& d)
> {
> begin_ = begin_ - d;
> last_ = last_ + d;
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::contains(const point_rep& point) const
> {
> return ((point >= begin_) &&
> (point <= last_));
> }
>
>
>
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::contains(const period<point_rep,duration_rep>& other) const
> {
> return ((begin_ <= other.begin_) && (last_ >= other.last_));
> }
># 235 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool
> period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const
> {
> return (other.begin() == end() ||
> begin_ == other.end());
> }
># 254 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool
> period<point_rep,duration_rep>::is_after(const point_rep& t) const
> {
> if (is_null())
> {
> return false;
> }
>
> return t < begin_;
> }
># 276 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool
> period<point_rep,duration_rep>::is_before(const point_rep& t) const
> {
> if (is_null())
> {
> return false;
> }
>
> return last_ < t;
> }
># 301 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const
> {
> return ( contains(other.begin_) ||
> other.contains(begin_) ||
> ((other.begin_ < begin_) && (other.last_ >= begin_)));
> }
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>
> period<point_rep,duration_rep>::intersection(const period<point_rep,duration_rep>& other) const
> {
> if (begin_ > other.begin_) {
> if (last_ <= other.last_) {
> return *this;
> }
>
> return period<point_rep,duration_rep>(begin_, other.end());
> }
> else {
> if (last_ <= other.last_) {
> return period<point_rep,duration_rep>(other.begin_, this->end());
> }
>
> return other;
> }
>
> }
>
>
>
>
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>
> period<point_rep,duration_rep>::merge(const period<point_rep,duration_rep>& other) const
> {
> if (this->intersects(other)) {
> if (begin_ < other.begin_) {
> return period<point_rep,duration_rep>(begin_, last_ > other.last_ ? this->end() : other.end());
> }
>
> return period<point_rep,duration_rep>(other.begin_, last_ > other.last_ ? this->end() : other.end());
>
> }
> return period<point_rep,duration_rep>(begin_,begin_);
> }
># 363 "/usr/include/boost/date_time/period.hpp" 3 4
> template<class point_rep, class duration_rep>
> inline
> period<point_rep,duration_rep>
> period<point_rep,duration_rep>::span(const period<point_rep,duration_rep>& other) const
> {
> point_rep start((begin_ < other.begin_) ? begin() : other.begin());
> point_rep newend((last_ < other.last_) ? other.end() : this->end());
> return period<point_rep,duration_rep>(start, newend);
> }
>
>
>} }
># 19 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 1 3 4
># 12 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 3 4
># 1 "/usr/include/boost/date_time/constrained_value.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
># 1 "/usr/include/boost/mpl/if.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/if.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/static_cast.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/static_cast.hpp" 2 3 4
># 18 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/config/integral.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/integral.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
># 73 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename T > struct value_type_wknd
>{
> typedef typename T::value_type type;
>};
># 87 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
>}}}
># 18 "/usr/include/boost/mpl/if.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
># 1 "/usr/include/boost/mpl/lambda_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/lambda_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/void_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/void_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
># 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
># 33 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
>namespace mpl_ { namespace aux {} }
>namespace boost { namespace mpl { using namespace mpl_;
>namespace aux { using namespace mpl_::aux; }
>}}
># 18 "/usr/include/boost/mpl/void_fwd.hpp" 2 3 4
>
>namespace mpl_ {
>
>struct void_;
>
>}
>namespace boost { namespace mpl { using ::mpl_::void_; } }
># 18 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/na.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
># 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/bool.hpp" 3 4
># 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
>namespace mpl_ {
>
>template< bool C_ > struct bool_;
>
>
>typedef bool_<true> true_;
>typedef bool_<false> false_;
>
>}
>
>namespace boost { namespace mpl { using ::mpl_::bool_; } }
>namespace boost { namespace mpl { using ::mpl_::true_; } }
>namespace boost { namespace mpl { using ::mpl_::false_; } }
># 18 "/usr/include/boost/mpl/bool.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
># 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4
>
>namespace mpl_ {
>struct integral_c_tag { static const int value = 0; };
>}
>namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
># 19 "/usr/include/boost/mpl/bool.hpp" 2 3 4
>
>
>namespace mpl_ {
>
>template< bool C_ > struct bool_
>{
> static const bool value = C_;
> typedef integral_c_tag tag;
> typedef bool_ type;
> typedef bool value_type;
> constexpr operator bool() const { return this->value; }
>};
>
>
>template< bool C_ >
>bool const bool_<C_>::value;
>
>
>}
># 18 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
># 19 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 3 4
>namespace mpl_ {
>
>
>struct na
>{
> typedef na type;
> enum { value = 0 };
>};
>
>}
>namespace boost { namespace mpl { using ::mpl_::na; } }
># 19 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
>
># 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
>
>namespace boost { namespace mpl {
>
>template< typename T >
>struct is_na
> : false_
>{
>
>
>
>};
>
>template<>
>struct is_na<na>
> : true_
>{
>
>
>
>};
>
>template< typename T >
>struct is_not_na
> : true_
>{
>
>
>
>};
>
>template<>
>struct is_not_na<na>
> : false_
>{
>
>
>
>};
>
>
>template< typename T, typename U > struct if_na
>{
> typedef T type;
>};
>
>template< typename U > struct if_na<na,U>
>{
> typedef U type;
>};
># 93 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
>}}
># 19 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/int.hpp" 3 4
># 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
># 19 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4
>
>namespace mpl_ {
>
>template< int N > struct int_;
>
>}
>namespace boost { namespace mpl { using ::mpl_::int_; } }
># 18 "/usr/include/boost/mpl/int.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
># 22 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/cat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/cat.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
># 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
>namespace mpl_ {
>
>template< int N >
>struct int_
>{
> static const int value = N;
>
>
>
>
>
> typedef int_ type;
>
> typedef int value_type;
> typedef integral_c_tag tag;
># 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
> typedef mpl_::int_< static_cast<int>((value + 1)) > next;
> typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
>
>
>
>
>
>
> constexpr operator int() const { return static_cast<int>(this->value); }
>};
>
>
>template< int N >
>int const mpl_::int_< N >::value;
>
>
>}
># 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
># 24 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
>namespace boost { namespace mpl { namespace aux {
>
>template< typename F > struct template_arity;
>
>}}}
># 26 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
>
>namespace boost { namespace mpl {
>
>template<
> typename T = na
> , typename Tag = void_
> , typename Arity = int_< aux::template_arity<T>::value >
>
>
> >
>struct lambda;
>
>}}
># 19 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/aux_/arity.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/arity.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/arity.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
># 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 45 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/comma_if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
># 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
># 16 "/usr/include/boost/preprocessor/comma_if.hpp" 2 3 4
># 46 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/repeat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
># 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
># 16 "/usr/include/boost/preprocessor/repeat.hpp" 2 3 4
># 47 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/inc.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/inc.hpp" 2 3 4
># 48 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
># 27 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
># 28 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
># 17 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
># 1 "/usr/include/boost/mpl/limits/arity.hpp" 1 3 4
># 18 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/preprocessor/logical/and.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/logical/and.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/logical/and.hpp" 2 3 4
># 23 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/identity.hpp" 1 3 4
># 15 "/usr/include/boost/preprocessor/identity.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/identity.hpp" 2 3 4
># 24 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/empty.hpp" 1 3 4
># 25 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 66 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
># 41 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
>
># 1 "/usr/include/boost/preprocessor/list/adt.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
># 16 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/check.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
># 19 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/logical/compl.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
># 20 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
># 42 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
># 22 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
># 37 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/list/reverse.hpp" 1 3 4
># 19 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
># 38 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
># 23 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 48 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
># 49 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
># 21 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/facilities/expand.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
># 17 "/usr/include/boost/preprocessor/facilities/overload.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/variadic/size.hpp" 1 3 4
># 18 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
># 22 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
># 20 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
># 1 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3 4
># 21 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
># 23 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
># 24 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
># 22 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
># 67 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 1 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
># 68 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
># 29 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
># 36 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
># 20 "/usr/include/boost/mpl/if.hpp" 2 3 4
># 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
># 21 "/usr/include/boost/mpl/if.hpp" 2 3 4
>
>
>
>
>namespace boost { namespace mpl {
>
>
>
>template<
> bool C
> , typename T1
> , typename T2
> >
>struct if_c
>{
> typedef T1 type;
>};
>
>template<
> typename T1
> , typename T2
> >
>struct if_c<false,T1,T2>
>{
> typedef T2 type;
>};
>
>
>
>template<
> typename T1 = na
> , typename T2 = na
> , typename T3 = na
> >
>struct if_
>{
> private:
>
> typedef if_c<
>
>
>
> static_cast<bool>(T1::value)
>
> , T2
> , T3
> > almost_type_;
>
> public:
> typedef typename almost_type_::type type;
>
> 
>};
># 131 "/usr/include/boost/mpl/if.hpp" 3 4
>template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
>
>}}
># 17 "/usr/include/boost/date_time/constrained_value.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_base_of.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/is_base_of.hpp" 3 4
># 1 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 1 3 4
># 12 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
># 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
># 16 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
># 1 "/usr/include/boost/type_traits/detail/config.hpp" 1 3 4
># 17 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
># 13 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
># 30 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
>namespace mpl_{
>
> template <bool B> struct bool_;
> template <class I, I val> struct integral_c;
> struct integral_c_tag;
>}
>
>namespace boost
>{
> namespace mpl
> {
> using ::mpl_::bool_;
> using ::mpl_::integral_c;
> using ::mpl_::integral_c_tag;
> }
>}
>
>
>
>namespace boost{
>
> template <class T, T val>
> struct integral_constant
> {
> typedef mpl::integral_c_tag tag;
> typedef T value_type;
> typedef integral_constant<T, val> type;
> static const T value = val;
>
>
>
>
> template <class U>
> static U& dereference(U* p) { return *p; }
>
> operator const mpl::integral_c<T, val>& ()const
> {
> static const char data[sizeof(long)] = { 0 };
> return dereference(reinterpret_cast<const mpl::integral_c<T, val>*>(&data));
> }
> constexpr operator T()const { return val; }
> };
>
> template <class T, T val>
> T const integral_constant<T, val>::value;
>
> template <bool val>
> struct integral_constant<bool, val>
> {
> typedef mpl::integral_c_tag tag;
> typedef bool value_type;
> typedef integral_constant<bool, val> type;
> static const bool value = val;
>
>
>
>
> template <class T>
> static T& dereference(T* p) { return *p; }
>
> operator const mpl::bool_<val>& ()const
> {
> static const char data = 0;
> return dereference(reinterpret_cast<const mpl::bool_<val>*>(&data));
> }
> constexpr operator bool()const { return val; }
> };
>
> template <bool val>
> bool const integral_constant<bool, val>::value;
>
> typedef integral_constant<bool, true> true_type;
> typedef integral_constant<bool, false> false_type;
>
>}
># 14 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
># 18 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
>namespace boost {
>
>
>template <class T> struct remove_cv{ typedef T type; };
>template <class T> struct remove_cv<T const>{ typedef T type; };
>template <class T> struct remove_cv<T volatile>{ typedef T type; };
>template <class T> struct remove_cv<T const volatile>{ typedef T type; };
>
>
>template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; };
>template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; };
>template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; };
>
>template <class T> struct remove_cv<T const[]>{ typedef T type[]; };
>template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; };
>template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };
>
>
>
>
>
> template <class T> using remove_cv_t = typename remove_cv<T>::type;
>
>
>
>}
># 22 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
># 1 "/usr/include/boost/type_traits/is_same.hpp" 1 3 4
># 26 "/usr/include/boost/type_traits/is_same.hpp" 3 4
>namespace boost {
>
>
> template <class T, class U> struct is_same : public false_type {};
> template <class T> struct is_same<T,T> : public true_type {};
>
>
>
>
>
>
>
>}
># 23 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
>
>namespace boost {
>
>namespace detail {
># 220 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
>template <typename B, typename D>
>struct is_base_and_derived_impl
>{
> typedef typename remove_cv::type ncvB;
> typedef typename remove_cv<D>::type ncvD;
>
> static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
>};
>
>}
>
>template <class Base, class Derived> struct is_base_and_derived
> : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};
>
>template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
>template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
>template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
>
>
>
>
>
>}
># 13 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
>
># 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
># 31 "/usr/include/boost/type_traits/is_class.hpp" 3 4
>namespace boost {
>
>namespace detail {
># 96 "/usr/include/boost/type_traits/is_class.hpp" 3 4
>template <typename T>
>struct is_class_impl
>{
> static const bool value = __is_class(T);
>};
>
>
>}
>
>template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
>
>
>
>
>
>
>}
># 15 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
>
>namespace boost {
>
> namespace detail{
> template <class B, class D>
> struct is_base_of_imp
> {
> typedef typename remove_cv::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{};
>
>}
># 18 "/usr/include/boost/date_time/constrained_value.hpp" 2 3 4
>
>namespace boost {
>
>
>namespace CV {
>
> enum violation_enum {min_violation, max_violation};
># 41 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
> template<class value_policies>
> class __attribute__((__visibility__("default"))) constrained_value {
> public:
> typedef typename value_policies::value_type value_type;
>
> constrained_value(value_type value) : value_((min)())
> {
> assign(value);
> }
> constrained_value& operator=(value_type v)
> {
> assign(v);
> return *this;
> }
>
> static value_type max () {return (value_policies::max)();}
>
> static value_type min () {return (value_policies::min)();}
>
> operator value_type() const {return value_;}
> protected:
> value_type value_;
> private:
> void assign(value_type value)
> {
>
>
> if (value+1 < (min)()+1) {
> value_policies::on_error(value_, value, min_violation);
> return;
> }
> if (value > (max)()) {
> value_policies::on_error(value_, value, max_violation);
> return;
> }
> value_ = value;
> }
>};
>
>
> template<typename rep_type, rep_type min_value,
> rep_type max_value, class exception_type>
> class __attribute__((__visibility__("default"))) simple_exception_policy
> {
> struct __attribute__((__visibility__("default"))) exception_wrapper : public exception_type
> {
>
>
>
>
> operator std::out_of_range () const
> {
>
> return std::out_of_range("constrained value boundary has been violated");
> }
> };
>
> typedef typename mpl::if_<
> is_base_of< std::exception, exception_type >,
> exception_type,
> exception_wrapper
> >::type actual_exception_type;
>
> public:
> typedef rep_type value_type;
> static rep_type min () { return min_value; }
> static rep_type max () { return max_value; }
> static void on_error(rep_type, rep_type, violation_enum)
> {
> boost::throw_exception(actual_exception_type());
> }
> };
>
>
>
>} }
># 13 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/date_defs.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/date_defs.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
>
>
> enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};
>
>} }
># 14 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace gregorian {
>
>
> using date_time::Sunday;
> using date_time::Monday;
> using date_time::Tuesday;
> using date_time::Wednesday;
> using date_time::Thursday;
> using date_time::Friday;
> using date_time::Saturday;
>
>
>
> struct __attribute__((__visibility__("default"))) bad_weekday : public std::out_of_range
> {
> bad_weekday() : std::out_of_range(std::string("Weekday is out of range 0..6")) {}
> };
> typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
> typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;
>
>
>
> class greg_weekday : public greg_weekday_rep {
> public:
> typedef boost::date_time::weekdays weekday_enum;
> greg_weekday(value_type day_of_week_num) :
> greg_weekday_rep(day_of_week_num)
> {}
>
> value_type as_number() const {return value_;}
> const char* as_short_string() const;
> const char* as_long_string() const;
>
> const wchar_t* as_short_wstring() const;
> const wchar_t* as_long_wstring() const;
>
> weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}
>
>
> };
>
>
>
>} }
># 15 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> struct __attribute__((__visibility__("default"))) bad_day_of_year : public std::out_of_range
> {
> bad_day_of_year() :
> std::out_of_range(std::string("Day of year value is out of range 1..366"))
> {}
> };
>
>
> typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;
>
>
> typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;
>
>
>} }
># 16 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian_calendar.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
>namespace boost {
>namespace date_time {
># 28 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
> template<typename ymd_type_, typename date_int_type_>
> class __attribute__((__visibility__("default"))) gregorian_calendar_base {
> public:
>
> typedef ymd_type_ ymd_type;
>
> typedef typename ymd_type::month_type month_type;
>
> typedef typename ymd_type::day_type day_type;
>
> typedef typename ymd_type::year_type year_type;
>
> typedef date_int_type_ date_int_type;
>
>
> static unsigned short day_of_week(const ymd_type& ymd);
> static int week_number(const ymd_type&ymd);
>
> static date_int_type day_number(const ymd_type& ymd);
> static date_int_type julian_day_number(const ymd_type& ymd);
> static date_int_type modjulian_day_number(const ymd_type& ymd);
> static ymd_type from_day_number(date_int_type);
> static ymd_type from_julian_day_number(date_int_type);
> static ymd_type from_modjulian_day_number(date_int_type);
> static bool is_leap_year(year_type);
> static unsigned short end_of_month_day(year_type y, month_type m);
> static ymd_type epoch();
> static unsigned short days_in_week();
>
> };
>
>
>
>} }
>
>
># 1 "/usr/include/boost/date_time/gregorian_calendar.ipp" 1 3 4
># 14 "/usr/include/boost/date_time/gregorian_calendar.ipp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> unsigned short
> gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
> unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
> unsigned short y = static_cast<unsigned short>(ymd.year - a);
> unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 2);
> unsigned short d = static_cast<unsigned short>((ymd.day + y + (y/4) - (y/100) + (y/400) + (31*m)/12) % 7);
>
> return d;
> }
>
>
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> int
> gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
> unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
> unsigned long juliantoday = julian_day_number(ymd);
> unsigned long day = (julianbegin + 3) % 7;
> unsigned long week = (juliantoday + day - julianbegin + 4)/7;
>
> if ((week >= 1) && (week <= 52)) {
> return static_cast<int>(week);
> }
>
> if (week == 53) {
> if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
> return static_cast<int>(week);
> } else {
> return 1;
> }
> }
>
> else if (week == 0) {
> julianbegin = julian_day_number(ymd_type(static_cast<unsigned short>(ymd.year-1),1,1));
> juliantoday = julian_day_number(ymd);
> day = (julianbegin + 3) % 7;
> week = (juliantoday + day - julianbegin + 4)/7;
> return static_cast<int>(week);
> }
>
> return static_cast<int>(week);
>
> }
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> date_int_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
> {
> unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
> unsigned short y = static_cast<unsigned short>(ymd.year + 4800 - a);
> unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 3);
> unsigned long d = ymd.day + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
> return static_cast<date_int_type>(d);
> }
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> date_int_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
> {
> return day_number(ymd);
> }
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> date_int_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
> {
> return julian_day_number(ymd)-2400001;
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
> {
> date_int_type a = dayNumber + 32044;
> date_int_type b = (4*a + 3)/146097;
> date_int_type c = a-((146097*b)/4);
> date_int_type d = (4*c + 3)/1461;
> date_int_type e = c - (1461*d)/4;
> date_int_type m = (5*e + 2)/153;
> unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
> unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
> year_type year = static_cast<unsigned short>(100*b + d - 4800 + (m/10));
>
>
> return ymd_type(static_cast<unsigned short>(year),month,day);
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
> {
> date_int_type a = dayNumber + 32044;
> date_int_type b = (4*a+3)/146097;
> date_int_type c = a - ((146097*b)/4);
> date_int_type d = (4*c + 3)/1461;
> date_int_type e = c - ((1461*d)/4);
> date_int_type m = (5*e + 2)/153;
> unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
> unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
> year_type year = static_cast<year_type>(100*b + d - 4800 + (m/10));
>
>
> return ymd_type(year,month,day);
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(date_int_type dayNumber) {
> date_int_type jd = dayNumber + 2400001;
> return from_julian_day_number(jd);
> }
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> bool
> gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
> {
>
> return (!(year % 4)) && ((year % 100) || (!(year % 400)));
> }
>
>
>
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> unsigned short
> gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
> month_type month)
> {
> switch (month) {
> case 2:
> if (is_leap_year(year)) {
> return 29;
> } else {
> return 28;
> };
> case 4:
> case 6:
> case 9:
> case 11:
> return 30;
> default:
> return 31;
> };
>
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> ymd_type_
> gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
> {
> return ymd_type(1400,1,1);
> }
>
>
> template<typename ymd_type_, typename date_int_type_>
> inline
> unsigned short
> gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
> {
> return 7;
> }
>
>
>} }
># 65 "/usr/include/boost/date_time/gregorian_calendar.hpp" 2 3 4
># 17 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> struct __attribute__((__visibility__("default"))) bad_day_of_month : public std::out_of_range
> {
> bad_day_of_month() :
> std::out_of_range(std::string("Day of month value is out of range 1..31"))
> {}
>
> bad_day_of_month(const std::string& s) :
> std::out_of_range(s)
> {}
> };
>
> typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;
>
>
> typedef CV::constrained_value<greg_day_policies> greg_day_rep;
>
>
>
>
>
>
>
> class __attribute__((__visibility__("default"))) greg_day : public greg_day_rep {
> public:
> greg_day(value_type day_of_month) : greg_day_rep(day_of_month) {}
> value_type as_number() const {return value_;}
> operator value_type() const {return value_;}
> private:
>
> };
>
>
>
>} }
># 15 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> struct __attribute__((__visibility__("default"))) bad_year : public std::out_of_range
> {
> bad_year() :
> std::out_of_range(std::string("Year is out of valid range: 1400..10000"))
> {}
> };
>
> typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;
>
>
> typedef CV::constrained_value<greg_year_policies> greg_year_rep;
># 40 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
> class __attribute__((__visibility__("default"))) greg_year : public greg_year_rep {
> public:
> greg_year(value_type year) : greg_year_rep(year) {}
> operator value_type() const {return value_;}
> };
>
>
>
>} }
># 16 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 1 3 4
># 20 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 3 4
># 1 "/usr/include/c++/8/cctype" 1 3 4
># 39 "/usr/include/c++/8/cctype" 3 4
> 
># 40 "/usr/include/c++/8/cctype" 3
># 21 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 2 3 4
>
>namespace boost {
>namespace gregorian {
>
> typedef date_time::months_of_year months_of_year;
>
>
> using date_time::Jan;
> using date_time::Feb;
> using date_time::Mar;
> using date_time::Apr;
> using date_time::May;
> using date_time::Jun;
> using date_time::Jul;
> using date_time::Aug;
> using date_time::Sep;
> using date_time::Oct;
> using date_time::Nov;
> using date_time::Dec;
> using date_time::NotAMonth;
> using date_time::NumMonths;
>
>
> struct __attribute__((__visibility__("default"))) bad_month : public std::out_of_range
> {
> bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {}
> };
>
> typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;
>
> typedef CV::constrained_value<greg_month_policies> greg_month_rep;
>
>
>
> class greg_month : public greg_month_rep {
> public:
> typedef date_time::months_of_year month_enum;
> typedef std::map<std::string, unsigned short> month_map_type;
> typedef boost::shared_ptr<month_map_type> month_map_ptr_type;
>
> greg_month(month_enum theMonth) :
> greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}
>
> greg_month(value_type theMonth) : greg_month_rep(theMonth) {}
>
> operator value_type() const {return value_;}
>
> value_type as_number() const {return value_;}
> month_enum as_enum() const {return static_cast<month_enum>(value_);}
> const char* as_short_string() const;
> const char* as_long_string() const;
>
> const wchar_t* as_short_wstring() const;
> const wchar_t* as_long_wstring() const;
>
>
> static month_map_ptr_type get_month_map_ptr();
>
>
>
> const char* as_short_string(char) const
> {
> return as_short_string();
> }
> const char* as_long_string(char) const
> {
> return as_long_string();
> }
>
> const wchar_t* as_short_string(wchar_t) const
> {
> return as_short_wstring();
> }
> const wchar_t* as_long_string(wchar_t) const
> {
> return as_long_wstring();
> }
>
> };
>
>} }
># 17 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
>
>namespace boost {
>namespace gregorian {
>
> typedef date_time::year_month_day_base<greg_year,
> greg_month,
> greg_day> greg_year_month_day;
>
>
>
>} }
># 18 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
>
>
>namespace boost {
>namespace gregorian {
>
>
> typedef date_time::int_adapter<uint32_t> fancy_date_rep;
>
>
> class __attribute__((__visibility__("default"))) gregorian_calendar :
> public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
> public:
>
> typedef greg_weekday day_of_week_type;
>
> typedef greg_day_of_year_rep day_of_year_type;
>
> typedef fancy_date_rep date_rep_type;
>
> typedef fancy_date_rep date_traits_type;
>
>
> private:
> };
>
>} }
># 20 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 3 4
># 1 "/usr/include/boost/date_time/date_duration.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/date_duration.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template<class duration_rep_traits>
> class __attribute__((__visibility__("default"))) date_duration : private
> boost::less_than_comparable1< date_duration< duration_rep_traits >
> , boost::equality_comparable1< date_duration< duration_rep_traits >
> , boost::addable1< date_duration< duration_rep_traits >
> , boost::subtractable1< date_duration< duration_rep_traits >
> , boost::dividable2< date_duration< duration_rep_traits >, int
> > > > > >
> {
> public:
> typedef typename duration_rep_traits::int_type duration_rep_type;
> typedef typename duration_rep_traits::impl_type duration_rep;
>
>
> explicit date_duration(duration_rep day_count) : days_(day_count) {}
>
>
>
> date_duration(special_values sv) :
> days_(duration_rep::from_special(sv))
> {}
>
>
>
> date_duration(const date_duration<duration_rep_traits>& other) :
> days_(other.days_)
> {}
>
>
> duration_rep get_rep()const
> {
> return days_;
> }
> bool is_special()const
> {
> return days_.is_special();
> }
>
> duration_rep_type days() const
> {
> return duration_rep_traits::as_number(days_);
> }
>
> static date_duration unit()
> {
> return date_duration<duration_rep_traits>(1);
> }
>
> bool operator==(const date_duration& rhs) const
> {
> return days_ == rhs.days_;
> }
>
> bool operator<(const date_duration& rhs) const
> {
> return days_ < rhs.days_;
> }
>
>
>
>
>
>
>
> date_duration& operator-=(const date_duration& rhs)
> {
>
> days_ = days_ - rhs.days_;
> return *this;
> }
>
> date_duration& operator+=(const date_duration& rhs)
> {
> days_ = days_ + rhs.days_;
> return *this;
> }
>
>
> date_duration operator-() const
> {
> return date_duration<duration_rep_traits>(get_rep() * (-1));
> }
>
> date_duration& operator/=(int divisor)
> {
> days_ = days_ / divisor;
> return *this;
> }
>
>
> bool is_negative() const
> {
> return days_ < 0;
> }
>
> private:
> duration_rep days_;
> };
>
>
>
>
>
> struct __attribute__((__visibility__("default"))) duration_traits_long
> {
> typedef long int_type;
> typedef long impl_type;
> static int_type as_number(impl_type i) { return i; }
> };
>
>
>
>
> struct __attribute__((__visibility__("default"))) duration_traits_adapted
> {
> typedef long int_type;
> typedef boost::date_time::int_adapter<long> impl_type;
> static int_type as_number(impl_type i) { return i.as_number(); }
> };
>
>
>} }
># 14 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace gregorian {
>
>
> typedef boost::date_time::duration_traits_adapted date_duration_rep;
>
>
>
>
> class __attribute__((__visibility__("default"))) date_duration :
> public boost::date_time::date_duration< date_duration_rep >
> {
> typedef boost::date_time::date_duration< date_duration_rep > base_type;
>
> public:
> typedef base_type::duration_rep duration_rep;
>
>
> explicit date_duration(duration_rep day_count = 0) : base_type(day_count) {}
>
>
> date_duration(date_time::special_values sv) : base_type(sv) {}
>
>
> date_duration(const date_duration& other) : base_type(static_cast< base_type const& >(other))
> {}
>
>
> date_duration(const base_type& other) : base_type(other)
> {}
>
>
>
>
>
> bool operator== (const date_duration& rhs) const
> {
> return base_type::operator== (rhs);
> }
> bool operator!= (const date_duration& rhs) const
> {
> return !operator== (rhs);
> }
> bool operator< (const date_duration& rhs) const
> {
> return base_type::operator< (rhs);
> }
> bool operator> (const date_duration& rhs) const
> {
> return !(base_type::operator< (rhs) || base_type::operator== (rhs));
> }
> bool operator<= (const date_duration& rhs) const
> {
> return (base_type::operator< (rhs) || base_type::operator== (rhs));
> }
> bool operator>= (const date_duration& rhs) const
> {
> return !base_type::operator< (rhs);
> }
>
>
> date_duration& operator-= (const date_duration& rhs)
> {
> base_type::operator-= (rhs);
> return *this;
> }
> friend date_duration operator- (date_duration rhs, date_duration const& lhs)
> {
> rhs -= lhs;
> return rhs;
> }
>
>
> date_duration& operator+= (const date_duration& rhs)
> {
> base_type::operator+= (rhs);
> return *this;
> }
> friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
> {
> rhs += lhs;
> return rhs;
> }
>
>
> date_duration operator- ()const
> {
> return date_duration(get_rep() * (-1));
> }
>
>
> date_duration& operator/= (int divisor)
> {
> base_type::operator/= (divisor);
> return *this;
> }
> friend date_duration operator/ (date_duration rhs, int lhs)
> {
> rhs /= lhs;
> return rhs;
> }
>
>
> static date_duration unit()
> {
> return date_duration(base_type::unit().get_rep());
> }
> };
>
>
> typedef date_duration days;
>
>} }
>
>
># 1 "/usr/include/boost/date_time/date_duration_types.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/date_duration_types.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template <class duration_config>
> class __attribute__((__visibility__("default"))) weeks_duration : public date_duration<duration_config> {
> public:
> weeks_duration(typename duration_config::impl_type w)
> : date_duration<duration_config>(w * 7) {}
> weeks_duration(special_values sv)
> : date_duration<duration_config>(sv) {}
> };
>
>
> template<class t>
> class __attribute__((__visibility__("default"))) years_duration;
>
>
>
>
>
>
> template<class base_config>
> class __attribute__((__visibility__("default"))) months_duration
> {
> private:
> typedef typename base_config::int_rep int_rep;
> typedef typename int_rep::int_type int_type;
> typedef typename base_config::date_type date_type;
> typedef typename date_type::duration_type duration_type;
> typedef typename base_config::month_adjustor_type month_adjustor_type;
> typedef months_duration<base_config> months_type;
> typedef years_duration<base_config> years_type;
> public:
> months_duration(int_rep num) : _m(num) {}
> months_duration(special_values sv) : _m(sv)
> {
> _m = int_rep::from_special(sv);
> }
> int_rep number_of_months() const { return _m; }
>
> duration_type get_neg_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_m.as_number());
> return duration_type(m_adj.get_neg_offset(d));
> }
> duration_type get_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_m.as_number());
> return duration_type(m_adj.get_offset(d));
> }
> bool operator==(const months_type& rhs) const
> {
> return(_m == rhs._m);
> }
> bool operator!=(const months_type& rhs) const
> {
> return(_m != rhs._m);
> }
> months_type operator+(const months_type& rhs)const
> {
> return months_type(_m + rhs._m);
> }
> months_type& operator+=(const months_type& rhs)
> {
> _m = _m + rhs._m;
> return *this;
> }
> months_type operator-(const months_type& rhs)const
> {
> return months_type(_m - rhs._m);
> }
> months_type& operator-=(const months_type& rhs)
> {
> _m = _m - rhs._m;
> return *this;
> }
> months_type operator*(const int_type rhs)const
> {
> return months_type(_m * rhs);
> }
> months_type& operator*=(const int_type rhs)
> {
> _m = _m * rhs;
> return *this;
> }
> months_type operator/(const int_type rhs)const
> {
> return months_type(_m / rhs);
> }
> months_type& operator/=(const int_type rhs)
> {
> _m = _m / rhs;
> return *this;
> }
> months_type operator+(const years_type& y)const
> {
> return months_type(y.number_of_years() * 12 + _m);
> }
> months_type& operator+=(const years_type& y)
> {
> _m = y.number_of_years() * 12 + _m;
> return *this;
> }
> months_type operator-(const years_type& y) const
> {
> return months_type(_m - y.number_of_years() * 12);
> }
> months_type& operator-=(const years_type& y)
> {
> _m = _m - y.number_of_years() * 12;
> return *this;
> }
>
>
> friend date_type operator+(const date_type& d, const months_type& m)
> {
> return d + m.get_offset(d);
> }
> friend date_type operator+=(date_type& d, const months_type& m)
> {
> return d += m.get_offset(d);
> }
> friend date_type operator-(const date_type& d, const months_type& m)
> {
>
> return d + m.get_neg_offset(d);
> }
> friend date_type operator-=(date_type& d, const months_type& m)
> {
>
> return d += m.get_neg_offset(d);
> }
>
> private:
> int_rep _m;
> };
>
>
>
>
>
>
>
> template<class base_config>
> class __attribute__((__visibility__("default"))) years_duration
> {
> private:
> typedef typename base_config::int_rep int_rep;
> typedef typename int_rep::int_type int_type;
> typedef typename base_config::date_type date_type;
> typedef typename date_type::duration_type duration_type;
> typedef typename base_config::month_adjustor_type month_adjustor_type;
> typedef years_duration<base_config> years_type;
> typedef months_duration<base_config> months_type;
> public:
> years_duration(int_rep num) : _y(num) {}
> years_duration(special_values sv) : _y(sv)
> {
> _y = int_rep::from_special(sv);
> }
> int_rep number_of_years() const { return _y; }
>
> duration_type get_neg_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_y.as_number() * 12);
> return duration_type(m_adj.get_neg_offset(d));
> }
> duration_type get_offset(const date_type& d) const
> {
> month_adjustor_type m_adj(_y.as_number() * 12);
> return duration_type(m_adj.get_offset(d));
> }
> bool operator==(const years_type& rhs) const
> {
> return(_y == rhs._y);
> }
> bool operator!=(const years_type& rhs) const
> {
> return(_y != rhs._y);
> }
> years_type operator+(const years_type& rhs)const
> {
> return years_type(_y + rhs._y);
> }
> years_type& operator+=(const years_type& rhs)
> {
> _y = _y + rhs._y;
> return *this;
> }
> years_type operator-(const years_type& rhs)const
> {
> return years_type(_y - rhs._y);
> }
> years_type& operator-=(const years_type& rhs)
> {
> _y = _y - rhs._y;
> return *this;
> }
> years_type operator*(const int_type rhs)const
> {
> return years_type(_y * rhs);
> }
> years_type& operator*=(const int_type rhs)
> {
> _y = _y * rhs;
> return *this;
> }
> years_type operator/(const int_type rhs)const
> {
> return years_type(_y / rhs);
> }
> years_type& operator/=(const int_type rhs)
> {
> _y = _y / rhs;
> return *this;
> }
> months_type operator+(const months_type& m) const
> {
> return(months_type(_y * 12 + m.number_of_months()));
> }
> months_type operator-(const months_type& m) const
> {
> return(months_type(_y * 12 - m.number_of_months()));
> }
>
>
> friend date_type operator+(const date_type& d, const years_type& y)
> {
> return d + y.get_offset(d);
> }
> friend date_type operator+=(date_type& d, const years_type& y)
> {
> return d += y.get_offset(d);
> }
> friend date_type operator-(const date_type& d, const years_type& y)
> {
>
> return d + y.get_neg_offset(d);
> }
> friend date_type operator-=(date_type& d, const years_type& y)
> {
>
> return d += y.get_neg_offset(d);
> }
>
> private:
> int_rep _y;
> };
>
>}}
># 133 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
># 21 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 3 4
># 1 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 1 3 4
># 19 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
>namespace boost {
>namespace gregorian {
>
>
> using date_time::special_values;
> using date_time::not_special;
> using date_time::neg_infin;
> using date_time::pos_infin;
> using date_time::not_a_date_time;
> using date_time::max_date_time;
> using date_time::min_date_time;
># 38 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
> class __attribute__((__visibility__("default"))) date : public date_time::date<date, gregorian_calendar, date_duration>
> {
> public:
> typedef gregorian_calendar::year_type year_type;
> typedef gregorian_calendar::month_type month_type;
> typedef gregorian_calendar::day_type day_type;
> typedef gregorian_calendar::day_of_year_type day_of_year_type;
> typedef gregorian_calendar::ymd_type ymd_type;
> typedef gregorian_calendar::date_rep_type date_rep_type;
> typedef gregorian_calendar::date_int_type date_int_type;
> typedef date_duration duration_type;
>
>
> date():
> date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
> {}
>
>
> date(year_type y, month_type m, day_type d)
> : date_time::date<date, gregorian_calendar, date_duration>(y, m, d)
> {
> if (gregorian_calendar::end_of_month_day(y, m) < d) {
> boost::throw_exception(bad_day_of_month(std::string("Day of month is not valid for year")));
> }
> }
>
> explicit date(const ymd_type& ymd)
> : date_time::date<date, gregorian_calendar, date_duration>(ymd)
> {}
>
> explicit date(const date_int_type& rhs):
> date_time::date<date,gregorian_calendar, date_duration>(rhs)
> {}
>
> explicit date(date_rep_type rhs):
> date_time::date<date,gregorian_calendar, date_duration>(rhs)
> {}
>
> explicit date(special_values sv):
> date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(sv))
> {
> if (sv == min_date_time)
> {
> *this = date(1400, 1, 1);
> }
> if (sv == max_date_time)
> {
> *this = date(9999, 12, 31);
> }
>
> }
>
> date_int_type julian_day() const
> {
> ymd_type ymd = year_month_day();
> return gregorian_calendar::julian_day_number(ymd);
> }
>
> day_of_year_type day_of_year() const
> {
> date start_of_year(year(), 1, 1);
> unsigned short doy = static_cast<unsigned short>((*this-start_of_year).days() + 1);
> return day_of_year_type(doy);
> }
>
> date_int_type modjulian_day() const
> {
> ymd_type ymd = year_month_day();
> return gregorian_calendar::modjulian_day_number(ymd);
> }
>
> int week_number() const
> {
> ymd_type ymd = year_month_day();
> return gregorian_calendar::week_number(ymd);
> }
>
> date_int_type day_number() const
> {
> return days_;
> }
>
> date end_of_month() const
> {
> ymd_type ymd = year_month_day();
> short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
> return date(ymd.year, ymd.month, eom_day);
> }
>
> private:
>
> };
>
>
>
>} }
># 14 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/adjust_functors.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
># 1 "/usr/include/boost/date_time/wrapping_int.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
>namespace boost {
>namespace date_time {
># 30 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
>template<typename int_type_, int_type_ wrap_val>
>class wrapping_int {
>public:
> typedef int_type_ int_type;
>
> static int_type wrap_value() {return wrap_val;}
>
> wrapping_int(int_type v) : value_(v) {}
>
> int_type as_int() const {return value_;}
> operator int_type() const {return value_;}
>
>
>
>
>
> template< typename IntT >
> IntT add(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_val));
> IntT overflow = static_cast<IntT>(v / (wrap_val));
> value_ = static_cast<int_type>(value_ + remainder);
> return calculate_wrap(overflow);
> }
>
>
>
>
>
>
> template< typename IntT >
> IntT subtract(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_val));
> IntT underflow = static_cast<IntT>(-(v / (wrap_val)));
> value_ = static_cast<int_type>(value_ - remainder);
> return calculate_wrap(underflow) * -1;
> }
>private:
> int_type value_;
>
> template< typename IntT >
> IntT calculate_wrap(IntT wrap)
> {
> if ((value_) >= wrap_val)
> {
> ++wrap;
> value_ -= (wrap_val);
> }
> else if(value_ < 0)
> {
> --wrap;
> value_ += (wrap_val);
> }
> return wrap;
> }
>
>};
>
>
>
>
>
>
>template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
>class wrapping_int2 {
>public:
> typedef int_type_ int_type;
> static int_type wrap_value() {return wrap_max;}
> static int_type min_value() {return wrap_min;}
>
>
> wrapping_int2(int_type v) : value_(v) {
> if(value_ < wrap_min)
> {
> value_ = wrap_min;
> }
> if(value_ > wrap_max)
> {
> value_ = wrap_max;
> }
> }
>
> int_type as_int() const {return value_;}
> operator int_type() const {return value_;}
>
>
>
>
>
> template< typename IntT >
> IntT add(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
> IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1));
> value_ = static_cast<int_type>(value_ + remainder);
> return calculate_wrap(overflow);
> }
>
>
>
>
>
> template< typename IntT >
> IntT subtract(IntT v)
> {
> int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
> IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1)));
> value_ = static_cast<int_type>(value_ - remainder);
> return calculate_wrap(underflow);
> }
>
>private:
> int_type value_;
>
> template< typename IntT >
> IntT calculate_wrap(IntT wrap)
> {
> if ((value_) > wrap_max)
> {
> ++wrap;
> value_ -= (wrap_max - wrap_min + 1);
> }
> else if((value_) < wrap_min)
> {
> --wrap;
> value_ += (wrap_max - wrap_min + 1);
> }
> return wrap;
> }
>};
>
>
>
>} }
># 14 "/usr/include/boost/date_time/adjust_functors.hpp" 2 3 4
>
>namespace boost {
>namespace date_time {
>
>
>
> template<class date_type>
> class day_functor
> {
> public:
> typedef typename date_type::duration_type duration_type;
> day_functor(int f) : f_(f) {}
> duration_type get_offset(const date_type& d) const
> {
>
>
> d.year();
> return duration_type(f_);
> }
> duration_type get_neg_offset(const date_type& d) const
> {
>
> d.year();
> return duration_type(-f_);
> }
> private:
> int f_;
> };
># 53 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
> template<class date_type>
> class month_functor
> {
> public:
> typedef typename date_type::duration_type duration_type;
> typedef typename date_type::calendar_type cal_type;
> typedef typename cal_type::ymd_type ymd_type;
> typedef typename cal_type::day_type day_type;
>
> month_functor(int f) : f_(f), origDayOfMonth_(0) {}
> duration_type get_offset(const date_type& d) const
> {
> ymd_type ymd(d.year_month_day());
> if (origDayOfMonth_ == 0) {
> origDayOfMonth_ = ymd.day;
> day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
> if (endOfMonthDay == ymd.day) {
> origDayOfMonth_ = -1;
> }
> }
> typedef date_time::wrapping_int2<short,1,12> wrap_int2;
> wrap_int2 wi(ymd.month);
>
> const typename ymd_type::year_type year(static_cast<typename ymd_type::year_type::value_type>(ymd.year + wi.add(f_)));
>
>
>
> day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
>
> if (origDayOfMonth_ == -1) {
> return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
> }
> day_type dayOfMonth = origDayOfMonth_;
> if (dayOfMonth > resultingEndOfMonthDay) {
> dayOfMonth = resultingEndOfMonthDay;
> }
> return date_type(year, wi.as_int(), dayOfMonth) - d;
> }
>
> duration_type get_neg_offset(const date_type& d) const
> {
> ymd_type ymd(d.year_month_day());
> if (origDayOfMonth_ == 0) {
> origDayOfMonth_ = ymd.day;
> day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
> if (endOfMonthDay == ymd.day) {
> origDayOfMonth_ = -1;
> }
> }
> typedef date_time::wrapping_int2<short,1,12> wrap_int2;
> wrap_int2 wi(ymd.month);
>
> const typename ymd_type::year_type year(static_cast<typename ymd_type::year_type::value_type>(ymd.year + wi.subtract(f_)));
>
> day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));
>
> if (origDayOfMonth_ == -1) {
> return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
> }
> day_type dayOfMonth = origDayOfMonth_;
> if (dayOfMonth > resultingEndOfMonthDay) {
> dayOfMonth = resultingEndOfMonthDay;
> }
> return date_type(year, wi.as_int(), dayOfMonth) - d;
> }
> private:
> int f_;
> mutable short origDayOfMonth_;
> };
>
>
>
> template<class date_type>
> class week_functor
> {
> public:
> typedef typename date_type::duration_type duration_type;
> typedef typename date_type::calendar_type calendar_type;
> week_functor(int f) : f_(f) {}
> duration_type get_offset(const date_type& d) const
> {
>
>
> d.year();
> return duration_type(f_*calendar_type::days_in_week());
> }
> duration_type get_neg_offset(const date_type& d) const
> {
>
> d.year();
> return duration_type(-f_*calendar_type::days_in_week());
> }
> private:
> int f_;
> };
>
>
> template<class date_type>
> class year_functor
> {
> public:
>
> typedef typename date_type::duration_type duration_type;
> year_functor(int f) : _mf(f * 12) {}
> duration_type get_offset(const date_type& d) const
> {
> return _mf.get_offset(d);
> }
> duration_type get_neg_offset(const date_type& d) const
> {
> return _mf.get_neg_offset(d);
> }
> private:
> month_functor<date_type> _mf;
> };
>
>
>} }
># 16 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace gregorian {
>
>
> struct __attribute__((__visibility__("default"))) greg_durations_config {
> typedef date date_type;
> typedef date_time::int_adapter<int> int_rep;
> typedef date_time::month_functor<date_type> month_adjustor_type;
> };
>
> typedef date_time::months_duration<greg_durations_config> months;
> typedef date_time::years_duration<greg_durations_config> years;
>
> class __attribute__((__visibility__("default"))) weeks_duration : public date_duration {
> public:
> weeks_duration(duration_rep w)
> : date_duration(w * 7) {}
> weeks_duration(date_time::special_values sv)
> : date_duration(sv) {}
> };
>
> typedef weeks_duration weeks;
>
>}}
># 23 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/date_time/date_generators.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/date_generators.hpp" 3 4
># 1 "/usr/include/c++/8/sstream" 1 3 4
># 36 "/usr/include/c++/8/sstream" 3 4
> 
># 37 "/usr/include/c++/8/sstream" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>namespace __cxx11 {
># 64 "/usr/include/c++/8/sstream" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
> {
> struct __xfer_bufptrs;
> public:
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
>
>
> typedef _Alloc allocator_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
> typedef basic_string<char_type, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
>
> protected:
>
> ios_base::openmode _M_mode;
>
>
> __string_type _M_string;
>
> public:
># 99 "/usr/include/c++/8/sstream" 3
> explicit
> basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(__mode), _M_string()
> { }
># 112 "/usr/include/c++/8/sstream" 3
> explicit
> basic_stringbuf(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in | ios_base::out)
> : __streambuf_type(), _M_mode(),
> _M_string(__str.data(), __str.size(), __str.get_allocator())
> { _M_stringbuf_init(__mode); }
>
>
> basic_stringbuf(const basic_stringbuf&) = delete;
>
> basic_stringbuf(basic_stringbuf&& __rhs)
> : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
> { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
>
>
>
> basic_stringbuf&
> operator=(const basic_stringbuf&) = delete;
>
> basic_stringbuf&
> operator=(basic_stringbuf&& __rhs)
> {
> __xfer_bufptrs __st{__rhs, this};
> const __streambuf_type& __base = __rhs;
> __streambuf_type::operator=(__base);
> this->pubimbue(__rhs.getloc());
> _M_mode = __rhs._M_mode;
> _M_string = std::move(__rhs._M_string);
> __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
> return *this;
> }
>
> void
> swap(basic_stringbuf& __rhs)
> {
> __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
> __xfer_bufptrs __r_st{__rhs, this};
> __streambuf_type& __base = __rhs;
> __streambuf_type::swap(__base);
> __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
> std::swap(_M_mode, __rhs._M_mode);
> std::swap(_M_string, __rhs._M_string);
> }
># 166 "/usr/include/c++/8/sstream" 3
> __string_type
> str() const
> {
> __string_type __ret(_M_string.get_allocator());
> if (this->pptr())
> {
>
> if (this->pptr() > this->egptr())
> __ret.assign(this->pbase(), this->pptr());
> else
> __ret.assign(this->pbase(), this->egptr());
> }
> else
> __ret = _M_string;
> return __ret;
> }
># 190 "/usr/include/c++/8/sstream" 3
> void
> str(const __string_type& __s)
> {
>
>
> _M_string.assign(__s.data(), __s.size());
> _M_stringbuf_init(_M_mode);
> }
>
> protected:
>
> void
> _M_stringbuf_init(ios_base::openmode __mode)
> {
> _M_mode = __mode;
> __size_type __len = 0;
> if (_M_mode & (ios_base::ate | ios_base::app))
> __len = _M_string.size();
> _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
> }
>
> virtual streamsize
> showmanyc()
> {
> streamsize __ret = -1;
> if (_M_mode & ios_base::in)
> {
> _M_update_egptr();
> __ret = this->egptr() - this->gptr();
> }
> return __ret;
> }
>
> virtual int_type
> underflow();
>
> virtual int_type
> pbackfail(int_type __c = traits_type::eof());
>
> virtual int_type
> overflow(int_type __c = traits_type::eof());
># 243 "/usr/include/c++/8/sstream" 3
> virtual __streambuf_type*
> setbuf(char_type* __s, streamsize __n)
> {
> if (__s && __n >= 0)
> {
>
>
>
>
>
>
> _M_string.clear();
>
>
> _M_sync(__s, __n, 0);
> }
> return this;
> }
>
> virtual pos_type
> seekoff(off_type __off, ios_base::seekdir __way,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
> virtual pos_type
> seekpos(pos_type __sp,
> ios_base::openmode __mode = ios_base::in | ios_base::out);
>
>
>
>
> void
> _M_sync(char_type* __base, __size_type __i, __size_type __o);
>
>
>
> void
> _M_update_egptr()
> {
> const bool __testin = _M_mode & ios_base::in;
> if (this->pptr() && this->pptr() > this->egptr())
> {
> if (__testin)
> this->setg(this->eback(), this->gptr(), this->pptr());
> else
> this->setg(this->pptr(), this->pptr(), this->pptr());
> }
> }
>
>
>
> void
> _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
>
> private:
>
>
>
>
> struct __xfer_bufptrs
> {
> __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
> : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
> {
> const _CharT* const __str = __from._M_string.data();
> const _CharT* __end = nullptr;
> if (__from.eback())
> {
> _M_goff[0] = __from.eback() - __str;
> _M_goff[1] = __from.gptr() - __str;
> _M_goff[2] = __from.egptr() - __str;
> __end = __from.egptr();
> }
> if (__from.pbase())
> {
> _M_poff[0] = __from.pbase() - __str;
> _M_poff[1] = __from.pptr() - __from.pbase();
> _M_poff[2] = __from.epptr() - __str;
> if (__from.pptr() > __end)
> __end = __from.pptr();
> }
>
>
> if (__end)
> {
>
>
> auto& __mut_from = const_cast<basic_stringbuf&>(__from);
> __mut_from._M_string._M_length(__end - __str);
> }
> }
>
> ~__xfer_bufptrs()
> {
> char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
> if (_M_goff[0] != -1)
> _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
> if (_M_poff[0] != -1)
> _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
> }
>
> basic_stringbuf* _M_to;
> off_type _M_goff[3];
> off_type _M_poff[3];
> };
># 357 "/usr/include/c++/8/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))
> { }
>
> };
># 380 "/usr/include/c++/8/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:
># 416 "/usr/include/c++/8/sstream" 3
> explicit
> basic_istringstream(ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__mode | ios_base::in)
> { this->init(&_M_stringbuf); }
># 434 "/usr/include/c++/8/sstream" 3
> explicit
> basic_istringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::in)
> : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_istringstream()
> { }
>
>
> basic_istringstream(const basic_istringstream&) = delete;
>
> basic_istringstream(basic_istringstream&& __rhs)
> : __istream_type(std::move(__rhs)),
> _M_stringbuf(std::move(__rhs._M_stringbuf))
> { __istream_type::set_rdbuf(&_M_stringbuf); }
>
>
>
> basic_istringstream&
> operator=(const basic_istringstream&) = delete;
>
> basic_istringstream&
> operator=(basic_istringstream&& __rhs)
> {
> __istream_type::operator=(std::move(__rhs));
> _M_stringbuf = std::move(__rhs._M_stringbuf);
> return *this;
> }
>
> void
> swap(basic_istringstream& __rhs)
> {
> __istream_type::swap(__rhs);
> _M_stringbuf.swap(__rhs._M_stringbuf);
> }
># 485 "/usr/include/c++/8/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 524 "/usr/include/c++/8/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:
># 560 "/usr/include/c++/8/sstream" 3
> explicit
> basic_ostringstream(ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
> { this->init(&_M_stringbuf); }
># 578 "/usr/include/c++/8/sstream" 3
> explicit
> basic_ostringstream(const __string_type& __str,
> ios_base::openmode __mode = ios_base::out)
> : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_ostringstream()
> { }
>
>
> basic_ostringstream(const basic_ostringstream&) = delete;
>
> basic_ostringstream(basic_ostringstream&& __rhs)
> : __ostream_type(std::move(__rhs)),
> _M_stringbuf(std::move(__rhs._M_stringbuf))
> { __ostream_type::set_rdbuf(&_M_stringbuf); }
>
>
>
> basic_ostringstream&
> operator=(const basic_ostringstream&) = delete;
>
> basic_ostringstream&
> operator=(basic_ostringstream&& __rhs)
> {
> __ostream_type::operator=(std::move(__rhs));
> _M_stringbuf = std::move(__rhs._M_stringbuf);
> return *this;
> }
>
> void
> swap(basic_ostringstream& __rhs)
> {
> __ostream_type::swap(__rhs);
> _M_stringbuf.swap(__rhs._M_stringbuf);
> }
># 629 "/usr/include/c++/8/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
># 668 "/usr/include/c++/8/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:
># 703 "/usr/include/c++/8/sstream" 3
> explicit
> basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__m)
> { this->init(&_M_stringbuf); }
># 719 "/usr/include/c++/8/sstream" 3
> explicit
> basic_stringstream(const __string_type& __str,
> ios_base::openmode __m = ios_base::out | ios_base::in)
> : __iostream_type(), _M_stringbuf(__str, __m)
> { this->init(&_M_stringbuf); }
>
>
>
>
>
>
>
> ~basic_stringstream()
> { }
>
>
> basic_stringstream(const basic_stringstream&) = delete;
>
> basic_stringstream(basic_stringstream&& __rhs)
> : __iostream_type(std::move(__rhs)),
> _M_stringbuf(std::move(__rhs._M_stringbuf))
> { __iostream_type::set_rdbuf(&_M_stringbuf); }
>
>
>
> basic_stringstream&
> operator=(const basic_stringstream&) = delete;
>
> basic_stringstream&
> operator=(basic_stringstream&& __rhs)
> {
> __iostream_type::operator=(std::move(__rhs));
> _M_stringbuf = std::move(__rhs._M_stringbuf);
> return *this;
> }
>
> void
> swap(basic_stringstream& __rhs)
> {
> __iostream_type::swap(__rhs);
> _M_stringbuf.swap(__rhs._M_stringbuf);
> }
># 770 "/usr/include/c++/8/sstream" 3
> __stringbuf_type*
> rdbuf() const
> { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
>
>
>
>
>
> __string_type
> str() const
> { return _M_stringbuf.str(); }
>
>
>
>
>
>
>
> void
> str(const __string_type& __s)
> { _M_stringbuf.str(__s); }
> };
>
>
>
> template <class _CharT, class _Traits, class _Allocator>
> inline void
> swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
> basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
> { __x.swap(__y); }
>
>
> template <class _CharT, class _Traits, class _Allocator>
> inline void
> swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
> basic_istringstream<_CharT, _Traits, _Allocator>& __y)
> { __x.swap(__y); }
>
>
> template <class _CharT, class _Traits, class _Allocator>
> inline void
> swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
> basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
> { __x.swap(__y); }
>
>
> template <class _CharT, class _Traits, class _Allocator>
> inline void
> swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
> basic_stringstream<_CharT, _Traits, _Allocator>& __y)
> { __x.swap(__y); }
>
>
>}
>
>}
>
># 1 "/usr/include/c++/8/bits/sstream.tcc" 1 3
># 37 "/usr/include/c++/8/bits/sstream.tcc" 3
> 
># 38 "/usr/include/c++/8/bits/sstream.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> pbackfail(int_type __c)
> {
> int_type __ret = traits_type::eof();
> if (this->eback() < this->gptr())
> {
>
>
> const bool __testeof = traits_type::eq_int_type(__c, __ret);
> if (!__testeof)
> {
> const bool __testeq = traits_type::eq(traits_type::
> to_char_type(__c),
> this->gptr()[-1]);
> const bool __testout = this->_M_mode & ios_base::out;
> if (__testeq || __testout)
> {
> this->gbump(-1);
> if (!__testeq)
> *this->gptr() = traits_type::to_char_type(__c);
> __ret = __c;
> }
> }
> else
> {
> this->gbump(-1);
> __ret = traits_type::not_eof(__c);
> }
> }
> return __ret;
> }
>
> template <class _CharT, class _Traits, class _Alloc>
> typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
> basic_stringbuf<_CharT, _Traits, _Alloc>::
> overflow(int_type __c)
> {
> const bool __testout = this->_M_mode & ios_base::out;
> if (__builtin_expect(!__testout, false))
> return traits_type::eof();
>
> const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
> if (__builtin_expect(__testeof, false))
> return traits_type::not_eof(__c);
>
> const __size_type __capacity = _M_string.capacity();
>
>
> if ((this->epptr() - this->pbase()) < __capacity)
> {
>
> char_type* __base = const_cast<char_type*>(_M_string.data());
> _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
> if (_M_mode & ios_base::in)
> {
> const __size_type __nget = this->gptr() - this->eback();
> const __size_type __eget = this->egptr() - this->eback();
> this->setg(__base, __base + __nget, __base + __eget + 1);
> }
> *this->pptr() = traits_type::to_char_type(__c);
> this->pbump(1);
> return __c;
> }
>
>
> const __size_type __max_size = _M_string.max_size();
> const bool __testput = this->pptr() < this->epptr();
> if (__builtin_expect(!__testput && __capacity == __max_size, false))
> return traits_type::eof();
>
>
>
> const char_type __conv = traits_type::to_char_type(__c);
> if (!__testput)
> {
># 129 "/usr/include/c++/8/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>;
>
>
>
>
>}
># 828 "/usr/include/c++/8/sstream" 2 3
># 18 "/usr/include/boost/date_time/date_generators.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace date_time {
>
>
>
>
>
>
>
> template<class date_type>
> class year_based_generator
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::year_type year_type;
> year_based_generator() {}
> virtual ~year_based_generator() {}
> virtual date_type get_date(year_type y) const = 0;
>
> virtual std::string to_string() const =0;
> };
># 55 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class partial_date : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_type day_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
> typedef typename duration_type::duration_rep duration_rep;
> partial_date(day_type d, month_type m) :
> day_(d),
> month_(m)
> {}
>
>
>
>
>
> partial_date(duration_rep days) :
> day_(1),
> month_(1)
> {
> date_type d1(2000,1,1);
> if(days > 1) {
> if(days > 366)
> {
> days = 366;
> }
> days = days - 1;
> duration_type dd(days);
> d1 = d1 + dd;
> }
> day_ = d1.day();
> month_ = d1.month();
> }
># 101 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> date_type get_date(year_type y) const
> {
> if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
> std::ostringstream ss;
> ss << "No Feb 29th in given year of " << y << ".";
> boost::throw_exception(std::invalid_argument(ss.str()));
> }
> return date_type(y, month_, day_);
> }
> date_type operator()(year_type y) const
> {
> return get_date(y);
>
> }
> bool operator==(const partial_date& rhs) const
> {
> return (month_ == rhs.month_) && (day_ == rhs.day_);
> }
> bool operator<(const partial_date& rhs) const
> {
> if (month_ < rhs.month_) return true;
> if (month_ > rhs.month_) return false;
>
> return (day_ < rhs.day_);
> }
>
>
> month_type month() const
> {
> return month_;
> }
> day_type day() const
> {
> return day_;
> }
>
>
>
>
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> date_type d(2004, month_, day_);
> unsigned short c = d.day_of_year();
> c--;
> ss << c;
> return ss.str();
> }
> private:
> day_type day_;
> month_type month_;
> };
>
>
>
> const char* nth_as_str(int n);
># 177 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class nth_kday_of_month : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
> enum week_num {first=1, second, third, fourth, fifth};
> nth_kday_of_month(week_num week_no,
> day_of_week_type dow,
> month_type m) :
> month_(m),
> wn_(week_no),
> dow_(dow)
> {}
>
> date_type get_date(year_type y) const
> {
> date_type d(y, month_, 1);
> duration_type one_day(1);
> duration_type one_week(7);
> while (dow_ != d.day_of_week()) {
> d = d + one_day;
> }
> int week = 1;
> while (week < wn_) {
> d = d + one_week;
> week++;
> }
>
> if(d.month() != month_) {
> d = d - one_week;
> }
> return d;
> }
>
> month_type month() const
> {
> return month_;
> }
> week_num nth_week() const
> {
> return wn_;
> }
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
> const char* nth_week_as_str() const
> {
> return nth_as_str(wn_);
> }
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> ss << 'M'
> << static_cast<int>(month_) << '.'
> << static_cast<int>(wn_) << '.'
> << static_cast<int>(dow_);
> return ss.str();
> }
> private:
> month_type month_;
> week_num wn_;
> day_of_week_type dow_;
> };
>
>
>
>
>
> template<class date_type>
> class first_kday_of_month : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
>
>
>
>
> first_kday_of_month(day_of_week_type dow, month_type m) :
> month_(m),
> dow_(dow)
> {}
>
> date_type get_date(year_type year) const
> {
> date_type d(year, month_,1);
> duration_type one_day(1);
> while (dow_ != d.day_of_week()) {
> d = d + one_day;
> }
> return d;
> }
>
> month_type month() const
> {
> return month_;
> }
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> ss << 'M'
> << static_cast<int>(month_) << '.'
> << 1 << '.'
> << static_cast<int>(dow_);
> return ss.str();
> }
> private:
> month_type month_;
> day_of_week_type dow_;
> };
># 313 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class last_kday_of_month : public year_based_generator<date_type>
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename calendar_type::month_type month_type;
> typedef typename calendar_type::year_type year_type;
> typedef typename date_type::duration_type duration_type;
>
>
>
>
> last_kday_of_month(day_of_week_type dow, month_type m) :
> month_(m),
> dow_(dow)
> {}
>
> date_type get_date(year_type year) const
> {
> date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
> duration_type one_day(1);
> while (dow_ != d.day_of_week()) {
> d = d - one_day;
> }
> return d;
> }
>
> month_type month() const
> {
> return month_;
> }
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
>
>
> virtual std::string to_string() const
> {
> std::ostringstream ss;
> ss << 'M'
> << static_cast<int>(month_) << '.'
> << 5 << '.'
> << static_cast<int>(dow_);
> return ss.str();
> }
> private:
> month_type month_;
> day_of_week_type dow_;
> };
># 375 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class first_kday_after
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename date_type::duration_type duration_type;
> first_kday_after(day_of_week_type dow) :
> dow_(dow)
> {}
>
> date_type get_date(date_type start_day) const
> {
> duration_type one_day(1);
> date_type d = start_day + one_day;
> while (dow_ != d.day_of_week()) {
> d = d + one_day;
> }
> return d;
> }
>
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
> private:
> day_of_week_type dow_;
> };
># 413 "/usr/include/boost/date_time/date_generators.hpp" 3 4
> template<class date_type>
> class first_kday_before
> {
> public:
> typedef typename date_type::calendar_type calendar_type;
> typedef typename calendar_type::day_of_week_type day_of_week_type;
> typedef typename date_type::duration_type duration_type;
> first_kday_before(day_of_week_type dow) :
> dow_(dow)
> {}
>
> date_type get_date(date_type start_day) const
> {
> duration_type one_day(1);
> date_type d = start_day - one_day;
> while (dow_ != d.day_of_week()) {
> d = d - one_day;
> }
> return d;
> }
>
> day_of_week_type day_of_week() const
> {
> return dow_;
> }
> private:
> day_of_week_type dow_;
> };
>
>
>
>
>
> template<typename date_type, class weekday_type>
> inline
> typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
> {
> typedef typename date_type::duration_type duration_type;
> duration_type wks(0);
> duration_type dd(wd.as_number() - d.day_of_week().as_number());
> if(dd.is_negative()){
> wks = duration_type(7);
> }
> return dd + wks;
> }
>
>
>
>
>
>
> template<typename date_type, class weekday_type>
> inline
> typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
> {
> typedef typename date_type::duration_type duration_type;
> duration_type wks(0);
> duration_type dd(wd.as_number() - d.day_of_week().as_number());
> if(dd.days() > 0){
> wks = duration_type(7);
> }
>
>
> return (-dd + wks);
> }
>
>
>
>
>
>
> template<class date_type, class weekday_type>
> inline
> date_type next_weekday(const date_type& d, const weekday_type& wd)
> {
> return d + days_until_weekday(d, wd);
> }
>
>
>
>
>
>
> template<class date_type, class weekday_type>
> inline
> date_type previous_weekday(const date_type& d, const weekday_type& wd)
> {
> return d - days_before_weekday(d, wd);
> }
>
>} }
># 26 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/date_clock_device.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/date_clock_device.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
>
>
>
>
> template<class date_type>
> class day_clock
> {
> public:
> typedef typename date_type::ymd_type ymd_type;
>
> static date_type local_day()
> {
> return date_type(local_day_ymd());
> }
>
> static typename date_type::ymd_type local_day_ymd()
> {
> ::std::tm result;
> ::std::tm* curr = get_local_time(result);
> return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
> static_cast<unsigned short>(curr->tm_mon + 1),
> static_cast<unsigned short>(curr->tm_mday));
> }
>
> static typename date_type::ymd_type universal_day_ymd()
> {
> ::std::tm result;
> ::std::tm* curr = get_universal_time(result);
> return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
> static_cast<unsigned short>(curr->tm_mon + 1),
> static_cast<unsigned short>(curr->tm_mday));
> }
>
> static date_type universal_day()
> {
> return date_type(universal_day_ymd());
> }
>
> private:
> static ::std::tm* get_local_time(std::tm& result)
> {
> ::std::time_t t;
> ::std::time(&t);
> return c_time::localtime(&t, &result);
> }
> static ::std::tm* get_universal_time(std::tm& result)
> {
> ::std::time_t t;
> ::std::time(&t);
> return c_time::gmtime(&t, &result);
> }
>
> };
>
>} }
># 27 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/date_iterator.hpp" 1 3 4
># 14 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
>namespace boost {
>namespace date_time {
>
> enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
># 32 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
> template<class date_type>
> class date_itr_base {
>
>
>
> public:
> typedef typename date_type::duration_type duration_type;
> typedef date_type value_type;
> typedef std::input_iterator_tag iterator_category;
>
> date_itr_base(date_type d) : current_(d) {}
> virtual ~date_itr_base() {}
> date_itr_base& operator++()
> {
> current_ = current_ + get_offset(current_);
> return *this;
> }
> date_itr_base& operator--()
> {
> current_ = current_ + get_neg_offset(current_);
> return *this;
> }
> virtual duration_type get_offset(const date_type& current) const=0;
> virtual duration_type get_neg_offset(const date_type& current) const=0;
> date_type operator*() {return current_;}
> date_type* operator->() {return &current_;}
> bool operator< (const date_type& d) {return current_ < d;}
> bool operator<= (const date_type& d) {return current_ <= d;}
> bool operator> (const date_type& d) {return current_ > d;}
> bool operator>= (const date_type& d) {return current_ >= d;}
> bool operator== (const date_type& d) {return current_ == d;}
> bool operator!= (const date_type& d) {return current_ != d;}
> private:
> date_type current_;
> };
># 76 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
> template<class offset_functor, class date_type>
> class date_itr : public date_itr_base<date_type> {
> public:
> typedef typename date_type::duration_type duration_type;
> date_itr(date_type d, int factor=1) :
> date_itr_base<date_type>(d),
> of_(factor)
> {}
> private:
> virtual duration_type get_offset(const date_type& current) const
> {
> return of_.get_offset(current);
> }
> virtual duration_type get_neg_offset(const date_type& current) const
> {
> return of_.get_neg_offset(current);
> }
> offset_functor of_;
> };
>
>
>
>} }
># 28 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
>
>
>namespace boost {
>
>
>
>
>
>
>namespace gregorian {
>
>
>
> typedef date_time::period<date, date_duration> date_period;
>
>
>
>
>
>
> typedef date_time::year_based_generator<date> year_based_generator;
>
>
> typedef date_time::partial_date<date> partial_date;
>
> typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
> typedef nth_kday_of_month nth_day_of_the_week_in_month;
>
> typedef date_time::first_kday_of_month<date> first_kday_of_month;
> typedef first_kday_of_month first_day_of_the_week_in_month;
>
> typedef date_time::last_kday_of_month<date> last_kday_of_month;
> typedef last_kday_of_month last_day_of_the_week_in_month;
>
> typedef date_time::first_kday_after<date> first_kday_after;
> typedef first_kday_after first_day_of_the_week_after;
>
> typedef date_time::first_kday_before<date> first_kday_before;
> typedef first_kday_before first_day_of_the_week_before;
>
>
>
>
> typedef date_time::day_clock<date> day_clock;
>
>
>
>
> typedef date_time::date_itr_base<date> date_iterator;
>
>
>
>
> typedef date_time::date_itr<date_time::day_functor<date>,
> date> day_iterator;
>
>
>
> typedef date_time::date_itr<date_time::week_functor<date>,
> date> week_iterator;
>
>
>
> typedef date_time::date_itr<date_time::month_functor<date>,
> date> month_iterator;
>
>
>
> typedef date_time::date_itr<date_time::year_functor<date>,
> date> year_iterator;
>
>
> using date_time::days_until_weekday;
> using date_time::days_before_weekday;
> using date_time::next_weekday;
> using date_time::previous_weekday;
>
>} }
># 19 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace posix_time {
># 40 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
> typedef date_time::time_resolution_traits<
> boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
> 1000000, 6 > time_res_traits;
># 57 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
> class __attribute__((__visibility__("default"))) time_duration :
> public date_time::time_duration<time_duration, time_res_traits>
> {
> public:
> typedef time_res_traits rep_type;
> typedef time_res_traits::day_type day_type;
> typedef time_res_traits::hour_type hour_type;
> typedef time_res_traits::min_type min_type;
> typedef time_res_traits::sec_type sec_type;
> typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
> typedef time_res_traits::tick_type tick_type;
> typedef time_res_traits::impl_type impl_type;
> time_duration(hour_type hour,
> min_type min,
> sec_type sec,
> fractional_seconds_type fs=0) :
> date_time::time_duration<time_duration, time_res_traits>(hour,min,sec,fs)
> {}
> time_duration() :
> date_time::time_duration<time_duration, time_res_traits>(0,0,0)
> {}
>
> time_duration(boost::date_time::special_values sv) :
> date_time::time_duration<time_duration, time_res_traits>(sv)
> {}
>
> friend class date_time::time_duration<time_duration, time_res_traits>;
> protected:
> explicit time_duration(impl_type tick_count) :
> date_time::time_duration<time_duration, time_res_traits>(tick_count)
> {}
> };
># 154 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
> class millisec_posix_time_system_config
> {
> public:
> typedef boost::int64_t time_rep_type;
>
> typedef gregorian::date date_type;
> typedef gregorian::date_duration date_duration_type;
> typedef time_duration time_duration_type;
> typedef time_res_traits::tick_type int_type;
> typedef time_res_traits::impl_type impl_type;
> typedef time_res_traits resolution_traits;
>
>
> static const boost::int64_t tick_per_second = 1000000;
>
> };
>
>
>
>} }
># 14 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_system_split.hpp" 1 3 4
># 17 "/usr/include/boost/date_time/time_system_split.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
>
>
> template<typename config>
>
> class split_timedate_system
> {
> public:
> typedef typename config::time_rep_type time_rep_type;
> typedef typename config::date_type date_type;
> typedef typename config::time_duration_type time_duration_type;
> typedef typename config::date_duration_type date_duration_type;
> typedef typename config::int_type int_type;
> typedef typename config::resolution_traits resolution_traits;
>
>
>
>
>
> private:
> static const int_type ticks_per_day = 86400L * config::tick_per_second;
> public:
>
>
>
> typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;
>
>
>
> static time_rep_type get_time_rep(special_values sv)
> {
> switch (sv) {
> case not_a_date_time:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> case pos_infin:
> return time_rep_type(date_type(pos_infin),
> time_duration_type(pos_infin));
> case neg_infin:
> return time_rep_type(date_type(neg_infin),
> time_duration_type(neg_infin));
> case max_date_time: {
> time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
> return time_rep_type(date_type(max_date_time), td);
> }
> case min_date_time:
> return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));
>
> default:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
>
> }
>
> }
>
> static time_rep_type get_time_rep(const date_type& day,
> const time_duration_type& tod,
> date_time::dst_flags = not_dst)
> {
> if(day.is_special() || tod.is_special()) {
> if(day.is_not_a_date() || tod.is_not_a_date_time()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else if(day.is_pos_infinity()) {
> if(tod.is_neg_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(day, time_duration_type(pos_infin));
> }
> }
> else if(day.is_neg_infinity()) {
> if(tod.is_pos_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(day, time_duration_type(neg_infin));
> }
> }
> else if(tod.is_pos_infinity()) {
> if(day.is_neg_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(date_type(pos_infin), tod);
> }
> }
> else if(tod.is_neg_infinity()) {
> if(day.is_pos_infinity()) {
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> }
> else {
> return time_rep_type(date_type(neg_infin), tod);
> }
> }
> }
> return time_rep_type(day, tod);
> }
> static date_type get_date(const time_rep_type& val)
> {
> return date_type(val.day);
> }
> static time_duration_type get_time_of_day(const time_rep_type& val)
> {
> return time_duration_type(val.time_of_day);
> }
> static std::string zone_name(const time_rep_type&)
> {
> return std::string();
> }
> static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> return ((lhs.day == rhs.day) && (lhs.time_of_day == rhs.time_of_day));
> }
> static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> if (lhs.day < rhs.day) return true;
> if (lhs.day > rhs.day) return false;
> return (lhs.time_of_day < rhs.time_of_day);
> }
> static time_rep_type add_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> return time_rep_type(base.day+dd, base.time_of_day);
> }
> static time_rep_type subtract_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> return split_timedate_system::get_time_rep(base.day-dd, base.time_of_day);
> }
> static time_rep_type subtract_time_duration(const time_rep_type& base,
> const time_duration_type& td)
> {
> if(base.day.is_special() || td.is_special())
> {
> return split_timedate_system::get_time_rep(base.day, -td);
> }
> if (td.is_negative()) {
> time_duration_type td1 = td.invert_sign();
> return add_time_duration(base,td1);
> }
>
> wrap_int_type day_offset(base.time_of_day.ticks());
> date_duration_type day_overflow(static_cast<typename date_duration_type::duration_rep_type>(day_offset.subtract(td.ticks())));
>
> return time_rep_type(base.day-day_overflow,
> time_duration_type(0,0,0,day_offset.as_int()));
> }
> static time_rep_type add_time_duration(const time_rep_type& base,
> time_duration_type td)
> {
> if(base.day.is_special() || td.is_special()) {
> return split_timedate_system::get_time_rep(base.day, td);
> }
> if (td.is_negative()) {
> time_duration_type td1 = td.invert_sign();
> return subtract_time_duration(base,td1);
> }
>
> wrap_int_type day_offset(base.time_of_day.ticks());
> date_duration_type day_overflow(static_cast< typename date_duration_type::duration_rep_type >(day_offset.add(td.ticks())));
>
> return time_rep_type(base.day+day_overflow,
> time_duration_type(0,0,0,day_offset.as_int()));
> }
> static time_duration_type subtract_times(const time_rep_type& lhs,
> const time_rep_type& rhs)
> {
> date_duration_type dd = lhs.day - rhs.day;
> time_duration_type td(dd.days()*24,0,0);
> time_duration_type td2 = lhs.time_of_day - rhs.time_of_day;
> return td+td2;
>
> }
>
> };
>
>} }
># 15 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_system_counted.hpp" 1 3 4
># 18 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
> template<class config>
> struct counted_time_rep
> {
> typedef typename config::int_type int_type;
> typedef typename config::date_type date_type;
> typedef typename config::impl_type impl_type;
> typedef typename date_type::duration_type date_duration_type;
> typedef typename date_type::calendar_type calendar_type;
> typedef typename date_type::ymd_type ymd_type;
> typedef typename config::time_duration_type time_duration_type;
> typedef typename config::resolution_traits resolution_traits;
>
> counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
> : time_count_(1)
> {
> if(d.is_infinity() || d.is_not_a_date() || time_of_day.is_special()) {
> time_count_ = time_of_day.get_rep() + d.day_count();
>
> }
> else {
> time_count_ = (d.day_number() * frac_sec_per_day()) + time_of_day.ticks();
> }
> }
> explicit counted_time_rep(int_type count) :
> time_count_(count)
> {}
> explicit counted_time_rep(impl_type count) :
> time_count_(count)
> {}
> date_type date() const
> {
> if(time_count_.is_special()) {
> return date_type(time_count_.as_special());
> }
> else {
> typename calendar_type::date_int_type dc = static_cast<typename calendar_type::date_int_type>(day_count());
>
> ymd_type ymd = calendar_type::from_day_number(dc);
> return date_type(ymd);
> }
> }
>
> unsigned long day_count() const
> {
># 78 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
> return static_cast<unsigned long>(resolution_traits::as_number(time_count_) / frac_sec_per_day());
> }
> int_type time_count() const
> {
> return resolution_traits::as_number(time_count_);
> }
> int_type tod() const
> {
> return resolution_traits::as_number(time_count_) % frac_sec_per_day();
> }
> static int_type frac_sec_per_day()
> {
> int_type seconds_per_day = 60*60*24;
> int_type fractional_sec_per_sec(resolution_traits::res_adjust());
> return seconds_per_day*fractional_sec_per_sec;
> }
> bool is_pos_infinity()const
> {
> return impl_type::is_pos_inf(time_count_.as_number());
> }
> bool is_neg_infinity()const
> {
> return impl_type::is_neg_inf(time_count_.as_number());
> }
> bool is_not_a_date_time()const
> {
> return impl_type::is_not_a_number(time_count_.as_number());
> }
> bool is_special()const
> {
> return time_count_.is_special();
> }
> impl_type get_rep()const
> {
> return time_count_;
> }
> private:
> impl_type time_count_;
> };
>
>
> template<class time_rep>
> class counted_time_system
> {
> public:
> typedef time_rep time_rep_type;
> typedef typename time_rep_type::impl_type impl_type;
> typedef typename time_rep_type::time_duration_type time_duration_type;
> typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
> typedef typename time_rep_type::date_type date_type;
> typedef typename time_rep_type::date_duration_type date_duration_type;
>
>
> template<class T> static void unused_var(const T&) {}
>
> static time_rep_type get_time_rep(const date_type& day,
> const time_duration_type& tod,
> date_time::dst_flags dst=not_dst)
> {
> unused_var(dst);
> return time_rep_type(day, tod);
> }
>
> static time_rep_type get_time_rep(special_values sv)
> {
> switch (sv) {
> case not_a_date_time:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
> case pos_infin:
> return time_rep_type(date_type(pos_infin),
> time_duration_type(pos_infin));
> case neg_infin:
> return time_rep_type(date_type(neg_infin),
> time_duration_type(neg_infin));
> case max_date_time: {
> time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
> return time_rep_type(date_type(max_date_time), td);
> }
> case min_date_time:
> return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));
>
> default:
> return time_rep_type(date_type(not_a_date_time),
> time_duration_type(not_a_date_time));
>
> }
>
> }
>
> static date_type get_date(const time_rep_type& val)
> {
> return val.date();
> }
> static time_duration_type get_time_of_day(const time_rep_type& val)
> {
> if(val.is_special()) {
> return time_duration_type(val.get_rep().as_special());
> }
> else{
> return time_duration_type(0,0,0,val.tod());
> }
> }
> static std::string zone_name(const time_rep_type&)
> {
> return "";
> }
> static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> return (lhs.time_count() == rhs.time_count());
> }
> static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
> {
> return (lhs.time_count() < rhs.time_count());
> }
> static time_rep_type add_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> if(base.is_special() || dd.is_special()) {
> return(time_rep_type(base.get_rep() + dd.get_rep()));
> }
> else {
> return time_rep_type(base.time_count() + (dd.days() * time_rep_type::frac_sec_per_day()));
> }
> }
> static time_rep_type subtract_days(const time_rep_type& base,
> const date_duration_type& dd)
> {
> if(base.is_special() || dd.is_special()) {
> return(time_rep_type(base.get_rep() - dd.get_rep()));
> }
> else{
> return time_rep_type(base.time_count() - (dd.days() * time_rep_type::frac_sec_per_day()));
> }
> }
> static time_rep_type subtract_time_duration(const time_rep_type& base,
> const time_duration_type& td)
> {
> if(base.is_special() || td.is_special()) {
> return(time_rep_type(base.get_rep() - td.get_rep()));
> }
> else {
> return time_rep_type(base.time_count() - td.ticks());
> }
> }
> static time_rep_type add_time_duration(const time_rep_type& base,
> time_duration_type td)
> {
> if(base.is_special() || td.is_special()) {
> return(time_rep_type(base.get_rep() + td.get_rep()));
> }
> else {
> return time_rep_type(base.time_count() + td.ticks());
> }
> }
> static time_duration_type subtract_times(const time_rep_type& lhs,
> const time_rep_type& rhs)
> {
> if(lhs.is_special() || rhs.is_special()) {
> return(time_duration_type(
> impl_type::to_special((lhs.get_rep() - rhs.get_rep()).as_number())));
> }
> else {
> fractional_seconds_type fs = lhs.time_count() - rhs.time_count();
> return time_duration_type(0,0,0,fs);
> }
> }
>
> };
>
>
>} }
># 16 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
>
>
>
>namespace boost {
>namespace posix_time {
># 32 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
> typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
> typedef date_time::counted_time_system<int64_time_rep> posix_time_system;
>
>
>
>} }
># 13 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time.hpp" 1 3 4
># 21 "/usr/include/boost/date_time/time.hpp" 3 4
>namespace boost {
>namespace date_time {
># 45 "/usr/include/boost/date_time/time.hpp" 3 4
> template <class T, class time_system>
> class base_time : private
> boost::less_than_comparable<T
> , boost::equality_comparable<T
> > >
> {
> public:
>
> typedef void _is_boost_date_time_time_point;
> typedef T time_type;
> typedef typename time_system::time_rep_type time_rep_type;
> typedef typename time_system::date_type date_type;
> typedef typename time_system::date_duration_type date_duration_type;
> typedef typename time_system::time_duration_type time_duration_type;
>
>
> base_time(const date_type& day,
> const time_duration_type& td,
> dst_flags dst=not_dst) :
> time_(time_system::get_time_rep(day, td, dst))
> {}
> base_time(special_values sv) :
> time_(time_system::get_time_rep(sv))
> {}
> base_time(const time_rep_type& rhs) :
> time_(rhs)
> {}
> date_type date() const
> {
> return time_system::get_date(time_);
> }
> time_duration_type time_of_day() const
> {
> return time_system::get_time_of_day(time_);
> }
>
>
>
> std::string zone_name(bool =false) const
> {
> return time_system::zone_name(time_);
> }
>
>
>
> std::string zone_abbrev(bool =false) const
> {
> return time_system::zone_name(time_);
> }
>
> std::string zone_as_posix_string() const
> {
> return std::string();
> }
>
>
> bool is_not_a_date_time() const
> {
> return time_.is_not_a_date_time();
> }
>
> bool is_infinity() const
> {
> return (is_pos_infinity() || is_neg_infinity());
> }
>
> bool is_pos_infinity() const
> {
> return time_.is_pos_infinity();
> }
>
> bool is_neg_infinity() const
> {
> return time_.is_neg_infinity();
> }
>
> bool is_special() const
> {
> return(is_not_a_date_time() || is_infinity());
> }
>
> bool operator==(const time_type& rhs) const
> {
> return time_system::is_equal(time_,rhs.time_);
> }
>
> bool operator<(const time_type& rhs) const
> {
> return time_system::is_less(time_,rhs.time_);
> }
>
> time_duration_type operator-(const time_type& rhs) const
> {
> return time_system::subtract_times(time_, rhs.time_);
> }
>
> time_type operator+(const date_duration_type& dd) const
> {
> return time_system::add_days(time_, dd);
> }
> time_type operator+=(const date_duration_type& dd)
> {
> time_ = (time_system::get_time_rep(date() + dd, time_of_day()));
> return time_type(time_);
> }
>
> time_type operator-(const date_duration_type& dd) const
> {
> return time_system::subtract_days(time_, dd);
> }
> time_type operator-=(const date_duration_type& dd)
> {
> time_ = (time_system::get_time_rep(date() - dd, time_of_day()));
> return time_type(time_);
> }
>
> time_type operator+(const time_duration_type& td) const
> {
> return time_type(time_system::add_time_duration(time_, td));
> }
> time_type operator+=(const time_duration_type& td)
> {
> time_ = (time_system::get_time_rep(date(), time_of_day() + td));
> return time_type(time_);
> }
>
> time_type operator-(const time_duration_type& rhs) const
> {
> return time_system::subtract_time_duration(time_, rhs);
> }
> time_type operator-=(const time_duration_type& td)
> {
> time_ = (time_system::get_time_rep(date(), time_of_day() - td));
> return time_type(time_);
> }
>
> protected:
> time_rep_type time_;
> };
>
>
>
>
>
>} }
># 14 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
>
>
>namespace boost {
>
>namespace posix_time {
>
>
> using date_time::special_values;
> using date_time::not_special;
> using date_time::neg_infin;
> using date_time::pos_infin;
> using date_time::not_a_date_time;
> using date_time::max_date_time;
> using date_time::min_date_time;
>
>
>
>
> class __attribute__((__visibility__("default"))) ptime : public date_time::base_time<ptime, posix_time_system>
> {
> public:
> typedef posix_time_system time_system_type;
> typedef time_system_type::time_rep_type time_rep_type;
> typedef time_system_type::time_duration_type time_duration_type;
> typedef ptime time_type;
>
> ptime(gregorian::date d,time_duration_type td) : date_time::base_time<time_type,time_system_type>(d,td)
> {}
>
> explicit ptime(gregorian::date d) : date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
> {}
>
> ptime(const time_rep_type& rhs):
> date_time::base_time<time_type,time_system_type>(rhs)
> {}
>
> ptime(const special_values sv) : date_time::base_time<time_type,time_system_type>(sv)
> {}
>
>
> ptime() : date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time), time_duration_type(not_a_date_time))
> {}
>
>
> };
>
>
>
>} }
># 13 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
>namespace boost {
>namespace posix_time {
># 29 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
> inline
> ptime
> operator+(const ptime& t, const boost::gregorian::months& m)
> {
> return t + m.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator+=(ptime& t, const boost::gregorian::months& m)
> {
>
> return t += m.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-(const ptime& t, const boost::gregorian::months& m)
> {
>
> return t + m.get_neg_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-=(ptime& t, const boost::gregorian::months& m)
> {
> return t += m.get_neg_offset(t.date());
> }
>
>
>
>
>
>
> inline
> ptime
> operator+(const ptime& t, const boost::gregorian::years& y)
> {
> return t + y.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator+=(ptime& t, const boost::gregorian::years& y)
> {
> return t += y.get_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-(const ptime& t, const boost::gregorian::years& y)
> {
>
> return t + y.get_neg_offset(t.date());
> }
>
>
>
>
> inline
> ptime
> operator-=(ptime& t, const boost::gregorian::years& y)
> {
>
> return t += y.get_neg_offset(t.date());
> }
>
>}}
># 15 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 1 3 4
># 15 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
>namespace boost {
>namespace posix_time {
>
>
>
>
> class __attribute__((__visibility__("default"))) hours : public time_duration
> {
> public:
> explicit hours(long h) :
> time_duration(static_cast<hour_type>(h),0,0)
> {}
> };
>
>
>
>
> class __attribute__((__visibility__("default"))) minutes : public time_duration
> {
> public:
> explicit minutes(long m) :
> time_duration(0,static_cast<min_type>(m),0)
> {}
> };
>
>
>
>
> class __attribute__((__visibility__("default"))) seconds : public time_duration
> {
> public:
> explicit seconds(long s) :
> time_duration(0,0,static_cast<sec_type>(s))
> {}
> };
>
>
>
>
>
> typedef date_time::subsecond_duration<time_duration,1000> millisec;
> typedef date_time::subsecond_duration<time_duration,1000> milliseconds;
>
>
>
>
> typedef date_time::subsecond_duration<time_duration,1000000> microsec;
> typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
># 79 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
>} }
># 17 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
># 1 "/usr/include/boost/date_time/posix_time/time_period.hpp" 1 3 4
># 16 "/usr/include/boost/date_time/posix_time/time_period.hpp" 3 4
>namespace boost {
>namespace posix_time {
>
>
>
>
> typedef date_time::period<ptime, time_duration> time_period;
>
>
>} }
># 19 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/time_iterator.hpp" 1 3 4
># 13 "/usr/include/boost/date_time/time_iterator.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>
>
> template<class time_type>
> class time_itr {
> public:
> typedef typename time_type::time_duration_type time_duration_type;
> time_itr(time_type t, time_duration_type d) : current_(t), offset_(d) {}
> time_itr& operator++()
> {
> current_ = current_ + offset_;
> return *this;
> }
> time_itr& operator--()
> {
> current_ = current_ - offset_;
> return *this;
> }
> time_type operator*() {return current_;}
> time_type* operator->() {return &current_;}
> bool operator< (const time_type& t) {return current_ < t;}
> bool operator<= (const time_type& t) {return current_ <= t;}
> bool operator!= (const time_type& t) {return current_ != t;}
> bool operator== (const time_type& t) {return current_ == t;}
> bool operator> (const time_type& t) {return current_ > t;}
> bool operator>= (const time_type& t) {return current_ >= t;}
>
> private:
> time_type current_;
> time_duration_type offset_;
> };
>
>
>
>} }
># 20 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
># 1 "/usr/include/boost/date_time/dst_rules.hpp" 1 3 4
># 21 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
>namespace boost {
> namespace date_time {
>
> enum time_is_dst_result {is_not_in_dst, is_in_dst,
> ambiguous, invalid_time_label};
>
>
>
> template<class date_type_,
> class time_duration_type_>
> class dst_calculator
> {
> public:
> typedef time_duration_type_ time_duration_type;
> typedef date_type_ date_type;
># 47 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> process_local_dst_start_day(const time_duration_type& time_of_day,
> unsigned int dst_start_offset_minutes,
> long dst_length_minutes)
> {
>
> if (time_of_day < time_duration_type(0,dst_start_offset_minutes,0)) {
> return is_not_in_dst;
> }
> long offset = dst_start_offset_minutes + dst_length_minutes;
> if (time_of_day >= time_duration_type(0,offset,0)) {
> return is_in_dst;
> }
> return invalid_time_label;
> }
># 72 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> process_local_dst_end_day(const time_duration_type& time_of_day,
> unsigned int dst_end_offset_minutes,
> long dst_length_minutes)
> {
>
> int offset = dst_end_offset_minutes-dst_length_minutes;
> if (time_of_day < time_duration_type(0,offset,0)) {
> return is_in_dst;
> }
> if (time_of_day >= time_duration_type(0,dst_end_offset_minutes,0)) {
> return is_not_in_dst;
> }
> return ambiguous;
> }
># 100 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> local_is_dst(const date_type& current_day,
> const time_duration_type& time_of_day,
> const date_type& dst_start_day,
> const time_duration_type& dst_start_offset,
> const date_type& dst_end_day,
> const time_duration_type& dst_end_offset,
> const time_duration_type& dst_length_minutes)
> {
> unsigned int start_minutes = static_cast<unsigned>(
> dst_start_offset.hours() * 60 + dst_start_offset.minutes());
> unsigned int end_minutes = static_cast<unsigned>(
> dst_end_offset.hours() * 60 + dst_end_offset.minutes());
> long length_minutes = static_cast<long>(
> dst_length_minutes.hours() * 60 + dst_length_minutes.minutes());
>
> return local_is_dst(current_day, time_of_day,
> dst_start_day, start_minutes,
> dst_end_day, end_minutes,
> length_minutes);
> }
># 136 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> static time_is_dst_result
> local_is_dst(const date_type& current_day,
> const time_duration_type& time_of_day,
> const date_type& dst_start_day,
> unsigned int dst_start_offset_minutes,
> const date_type& dst_end_day,
> unsigned int dst_end_offset_minutes,
> long dst_length_minutes)
> {
>
> if (dst_start_day < dst_end_day) {
> if ((current_day > dst_start_day) && (current_day < dst_end_day)) {
> return is_in_dst;
> }
> if ((current_day < dst_start_day) || (current_day > dst_end_day)) {
> return is_not_in_dst;
> }
> }
> else {
> if ((current_day < dst_start_day) && (current_day > dst_end_day)) {
> return is_not_in_dst;
> }
> if ((current_day > dst_start_day) || (current_day < dst_end_day)) {
> return is_in_dst;
> }
> }
>
> if (current_day == dst_start_day) {
> return process_local_dst_start_day(time_of_day,
> dst_start_offset_minutes,
> dst_length_minutes);
> }
>
> if (current_day == dst_end_day) {
> return process_local_dst_end_day(time_of_day,
> dst_end_offset_minutes,
> dst_length_minutes);
> }
>
> return invalid_time_label;
> }
>
> };
># 208 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
> template<class date_type,
> class time_duration_type,
> class dst_traits>
> class dst_calc_engine
> {
> public:
> typedef typename date_type::year_type year_type;
> typedef typename date_type::calendar_type calendar_type;
> typedef dst_calculator<date_type, time_duration_type> dstcalc;
>
>
>
>
>
>
> static time_is_dst_result local_is_dst(const date_type& d,
> const time_duration_type& td)
> {
>
> year_type y = d.year();
> date_type dst_start = local_dst_start_day(y);
> date_type dst_end = local_dst_end_day(y);
> return dstcalc::local_is_dst(d,td,
> dst_start,
> dst_traits::dst_start_offset_minutes(),
> dst_end,
> dst_traits::dst_end_offset_minutes(),
> dst_traits::dst_shift_length_minutes());
>
> }
>
> static bool is_dst_boundary_day(date_type d)
> {
> year_type y = d.year();
> return ((d == local_dst_start_day(y)) ||
> (d == local_dst_end_day(y)));
> }
>
>
> static time_duration_type dst_offset()
> {
> return time_duration_type(0,dst_traits::dst_shift_length_minutes(),0);
> }
>
> static date_type local_dst_start_day(year_type year)
> {
> return dst_traits::local_dst_start_day(year);
> }
>
> static date_type local_dst_end_day(year_type year)
> {
> return dst_traits::local_dst_end_day(year);
> }
>
>
> };
>
>
>
>
>
>
> template<class date_type_,
> class time_duration_type_,
> unsigned int dst_start_offset_minutes=120,
> short dst_length_minutes=60>
> class us_dst_rules
> {
> public:
> typedef time_duration_type_ time_duration_type;
> typedef date_type_ date_type;
> typedef typename date_type::year_type year_type;
> typedef typename date_type::calendar_type calendar_type;
> typedef date_time::last_kday_of_month<date_type> lkday;
> typedef date_time::first_kday_of_month<date_type> fkday;
> typedef date_time::nth_kday_of_month<date_type> nkday;
> typedef dst_calculator<date_type, time_duration_type> dstcalc;
>
>
>
>
>
>
> static time_is_dst_result local_is_dst(const date_type& d,
> const time_duration_type& td)
> {
>
> year_type y = d.year();
> date_type dst_start = local_dst_start_day(y);
> date_type dst_end = local_dst_end_day(y);
> return dstcalc::local_is_dst(d,td,
> dst_start,dst_start_offset_minutes,
> dst_end, dst_start_offset_minutes,
> dst_length_minutes);
>
> }
>
>
> static bool is_dst_boundary_day(date_type d)
> {
> year_type y = d.year();
> return ((d == local_dst_start_day(y)) ||
> (d == local_dst_end_day(y)));
> }
>
> static date_type local_dst_start_day(year_type year)
> {
> if (year >= year_type(2007)) {
>
> nkday ssim(nkday::second, Sunday, gregorian::Mar);
> return ssim.get_date(year);
> } else {
>
> fkday fsia(Sunday, gregorian::Apr);
> return fsia.get_date(year);
> }
> }
>
> static date_type local_dst_end_day(year_type year)
> {
> if (year >= year_type(2007)) {
>
> fkday fsin(Sunday, gregorian::Nov);
> return fsin.get_date(year);
> } else {
>
> lkday lsio(Sunday, gregorian::Oct);
> return lsio.get_date(year);
> }
> }
>
> static time_duration_type dst_offset()
> {
> return time_duration_type(0,dst_length_minutes,0);
> }
>
> private:
>
>
> };
>
>
> template<class date_type_, class time_duration_type_>
> class null_dst_rules
> {
> public:
> typedef time_duration_type_ time_duration_type;
> typedef date_type_ date_type;
>
>
>
>
>
> static time_is_dst_result local_is_dst(const date_type&,
> const time_duration_type&)
> {
> return is_not_in_dst;
> }
>
>
> static time_is_dst_result utc_is_dst(const date_type&,
> const time_duration_type&)
> {
> return is_not_in_dst;
> }
>
> static bool is_dst_boundary_day(date_type )
> {
> return false;
> }
>
> static time_duration_type dst_offset()
> {
> return time_duration_type(0,0,0);
> }
>
> };
>
>
> } }
># 21 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
>
>namespace boost {
>
>
>namespace posix_time {
>
>
>
>
> typedef date_time::time_itr<ptime> time_iterator;
>
>
>
> typedef date_time::second_clock<ptime> second_clock;
>
>
>
>
>
> typedef date_time::microsec_clock<ptime> microsec_clock;
>
>
>
> typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;
>
> typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;
>
>
>} }
># 24 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Time>
>struct time_traits;
>
>
>template <>
>struct time_traits<boost::posix_time::ptime>
>{
>
> typedef boost::posix_time::ptime time_type;
>
>
> typedef boost::posix_time::time_duration duration_type;
>
>
> static time_type now()
> {
>
> return boost::posix_time::microsec_clock::universal_time();
>
>
>
> }
>
>
> static time_type add(const time_type& t, const duration_type& d)
> {
> return t + d;
> }
>
>
> static duration_type subtract(const time_type& t1, const time_type& t2)
> {
> return t1 - t2;
> }
>
>
> static bool less_than(const time_type& t1, const time_type& t2)
> {
> return t1 < t2;
> }
>
>
> static boost::posix_time::time_duration to_posix_duration(
> const duration_type& d)
> {
> return d;
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 84 "/usr/include/boost/asio/time_traits.hpp" 2 3 4
># 29 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/timer_queue.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/date_time_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/date_time_fwd.hpp" 3 4
>namespace boost {
>namespace date_time {
>
>template<class T, class TimeSystem>
>class base_time;
>
>}
>namespace posix_time {
>
>class ptime;
>
>}
>}
># 23 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>class timer_queue
> : public timer_queue_base
>{
>public:
>
> typedef typename Time_Traits::time_type time_type;
>
>
> typedef typename Time_Traits::duration_type duration_type;
>
>
> class per_timer_data
> {
> public:
> per_timer_data() :
> heap_index_((std::numeric_limits<std::size_t>::max)()),
> next_(0), prev_(0)
> {
> }
>
> private:
> friend class timer_queue;
>
>
> op_queue<wait_op> op_queue_;
>
>
> std::size_t heap_index_;
>
>
> per_timer_data* next_;
> per_timer_data* prev_;
> };
>
>
> timer_queue()
> : timers_(),
> heap_()
> {
> }
>
>
>
>
> bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
> {
>
> if (timer.prev_ == 0 && &timer != timers_)
> {
> if (this->is_positive_infinity(time))
> {
>
> timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
> }
> else
> {
>
>
> timer.heap_index_ = heap_.size();
> heap_entry entry = { time, &timer };
> heap_.push_back(entry);
> up_heap(heap_.size() - 1);
> }
>
>
> timer.next_ = timers_;
> timer.prev_ = 0;
> if (timers_)
> timers_->prev_ = &timer;
> timers_ = &timer;
> }
>
>
> timer.op_queue_.push(op);
>
>
> return timer.heap_index_ == 0 && timer.op_queue_.front() == op;
> }
>
>
> virtual bool empty() const
> {
> return timers_ == 0;
> }
>
>
> virtual long wait_duration_msec(long max_duration) const
> {
> if (heap_.empty())
> return max_duration;
>
> return this->to_msec(
> Time_Traits::to_posix_duration(
> Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
> max_duration);
> }
>
>
> virtual long wait_duration_usec(long max_duration) const
> {
> if (heap_.empty())
> return max_duration;
>
> return this->to_usec(
> Time_Traits::to_posix_duration(
> Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
> max_duration);
> }
>
>
> virtual void get_ready_timers(op_queue<operation>& ops)
> {
> if (!heap_.empty())
> {
> const time_type now = Time_Traits::now();
> while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
> {
> per_timer_data* timer = heap_[0].timer_;
> ops.push(timer->op_queue_);
> remove_timer(*timer);
> }
> }
> }
>
>
> virtual void get_all_timers(op_queue<operation>& ops)
> {
> while (timers_)
> {
> per_timer_data* timer = timers_;
> timers_ = timers_->next_;
> ops.push(timer->op_queue_);
> timer->next_ = 0;
> timer->prev_ = 0;
> }
>
> heap_.clear();
> }
>
>
> std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
> std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
> {
> std::size_t num_cancelled = 0;
> if (timer.prev_ != 0 || &timer == timers_)
> {
> while (wait_op* op = (num_cancelled != max_cancelled)
> ? timer.op_queue_.front() : 0)
> {
> op->ec_ = boost::asio::error::operation_aborted;
> timer.op_queue_.pop();
> ops.push(op);
> ++num_cancelled;
> }
> if (timer.op_queue_.empty())
> remove_timer(timer);
> }
> return num_cancelled;
> }
>
>
> void move_timer(per_timer_data& target, per_timer_data& source)
> {
> target.op_queue_.push(source.op_queue_);
>
> target.heap_index_ = source.heap_index_;
> source.heap_index_ = (std::numeric_limits<std::size_t>::max)();
>
> if (target.heap_index_ < heap_.size())
> heap_[target.heap_index_].timer_ = &target;
>
> if (timers_ == &source)
> timers_ = &target;
> if (source.prev_)
> source.prev_->next_ = &target;
> if (source.next_)
> source.next_->prev_= &target;
> target.next_ = source.next_;
> target.prev_ = source.prev_;
> source.next_ = 0;
> source.prev_ = 0;
> }
>
>private:
>
> void up_heap(std::size_t index)
> {
> while (index > 0)
> {
> std::size_t parent = (index - 1) / 2;
> if (!Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
> break;
> swap_heap(index, parent);
> index = parent;
> }
> }
>
>
> void down_heap(std::size_t index)
> {
> std::size_t child = index * 2 + 1;
> while (child < heap_.size())
> {
> std::size_t min_child = (child + 1 == heap_.size()
> || Time_Traits::less_than(
> heap_[child].time_, heap_[child + 1].time_))
> ? child : child + 1;
> if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_))
> break;
> swap_heap(index, min_child);
> index = min_child;
> child = index * 2 + 1;
> }
> }
>
>
> void swap_heap(std::size_t index1, std::size_t index2)
> {
> heap_entry tmp = heap_[index1];
> heap_[index1] = heap_[index2];
> heap_[index2] = tmp;
> heap_[index1].timer_->heap_index_ = index1;
> heap_[index2].timer_->heap_index_ = index2;
> }
>
>
> void remove_timer(per_timer_data& timer)
> {
>
> std::size_t index = timer.heap_index_;
> if (!heap_.empty() && index < heap_.size())
> {
> if (index == heap_.size() - 1)
> {
> heap_.pop_back();
> }
> else
> {
> swap_heap(index, heap_.size() - 1);
> heap_.pop_back();
> if (index > 0 && Time_Traits::less_than(
> heap_[index].time_, heap_[(index - 1) / 2].time_))
> up_heap(index);
> else
> down_heap(index);
> }
> }
>
>
> if (timers_ == &timer)
> timers_ = timer.next_;
> if (timer.prev_)
> timer.prev_->next_ = timer.next_;
> if (timer.next_)
> timer.next_->prev_= timer.prev_;
> timer.next_ = 0;
> timer.prev_ = 0;
> }
>
>
> template <typename Time_Type>
> static bool is_positive_infinity(const Time_Type&)
> {
> return false;
> }
>
>
> template <typename T, typename TimeSystem>
> static bool is_positive_infinity(
> const boost::date_time::base_time<T, TimeSystem>& time)
> {
> return time.is_pos_infinity();
> }
>
>
> template <typename Duration>
> long to_msec(const Duration& d, long max_duration) const
> {
> if (d.ticks() <= 0)
> return 0;
> int64_t msec = d.total_milliseconds();
> if (msec == 0)
> return 1;
> if (msec > max_duration)
> return max_duration;
> return static_cast<long>(msec);
> }
>
>
> template <typename Duration>
> long to_usec(const Duration& d, long max_duration) const
> {
> if (d.ticks() <= 0)
> return 0;
> int64_t usec = d.total_microseconds();
> if (usec == 0)
> return 1;
> if (usec > max_duration)
> return max_duration;
> return static_cast<long>(usec);
> }
>
>
> per_timer_data* timers_;
>
> struct heap_entry
> {
>
> time_type time_;
>
>
> per_timer_data* timer_;
> };
>
>
> std::vector<heap_entry> heap_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 359 "/usr/include/boost/asio/detail/timer_queue.hpp" 2 3 4
># 29 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
>
>
>template <>
>class timer_queue<time_traits<boost::posix_time::ptime> >
> : public timer_queue_base
>{
>public:
>
> typedef boost::posix_time::ptime time_type;
>
>
> typedef boost::posix_time::time_duration duration_type;
>
>
> typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
> per_timer_data;
>
>
> inline timer_queue();
>
>
> inline virtual ~timer_queue();
>
>
>
>
> inline bool enqueue_timer(const time_type& time,
> per_timer_data& timer, wait_op* op);
>
>
> inline virtual bool empty() const;
>
>
> inline virtual long wait_duration_msec(long max_duration) const;
>
>
> inline virtual long wait_duration_usec(long max_duration) const;
>
>
> inline virtual void get_ready_timers(op_queue<operation>& ops);
>
>
> inline virtual void get_all_timers(op_queue<operation>& ops);
>
>
> inline std::size_t cancel_timer(
> per_timer_data& timer, op_queue<operation>& ops,
> std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
>
>
> inline void move_timer(per_timer_data& target,
> per_timer_data& source);
>
>private:
> timer_queue<forwarding_posix_time_traits> impl_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 94 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 1 3 4
># 22 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 1 3 4
># 23 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue()
>{
>}
>
>timer_queue<time_traits<boost::posix_time::ptime> >::~timer_queue()
>{
>}
>
>bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
> const time_type& time, per_timer_data& timer, wait_op* op)
>{
> return impl_.enqueue_timer(time, timer, op);
>}
>
>bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
>{
> return impl_.empty();
>}
>
>long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_msec(
> long max_duration) const
>{
> return impl_.wait_duration_msec(max_duration);
>}
>
>long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_usec(
> long max_duration) const
>{
> return impl_.wait_duration_usec(max_duration);
>}
>
>void timer_queue<time_traits<boost::posix_time::ptime> >::get_ready_timers(
> op_queue<operation>& ops)
>{
> impl_.get_ready_timers(ops);
>}
>
>void timer_queue<time_traits<boost::posix_time::ptime> >::get_all_timers(
> op_queue<operation>& ops)
>{
> impl_.get_all_timers(ops);
>}
>
>std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
> per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled)
>{
> return impl_.cancel_timer(timer, ops, max_cancelled);
>}
>
>void timer_queue<time_traits<boost::posix_time::ptime> >::move_timer(
> per_timer_data& target, per_timer_data& source)
>{
> impl_.move_timer(target, source);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 90 "/usr/include/boost/asio/detail/impl/timer_queue_ptime.ipp" 2 3 4
># 97 "/usr/include/boost/asio/detail/timer_queue_ptime.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/timer_scheduler.hpp" 1 3 4
># 19 "/usr/include/boost/asio/detail/timer_scheduler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/timer_scheduler_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/timer_scheduler_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef class epoll_reactor timer_scheduler;
># 38 "/usr/include/boost/asio/detail/timer_scheduler_fwd.hpp" 3 4
>}
>}
>}
># 20 "/usr/include/boost/asio/detail/timer_scheduler.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/wait_handler.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/wait_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/detail/wait_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class wait_handler : public wait_op
>{
>public:
> struct ptr { Handler* h; wait_handler* v; wait_handler* p; ~ptr() { reset(); } static wait_handler* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<wait_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~wait_handler(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<wait_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<wait_handler*>(v), 1); v = 0; } } };
>
> wait_handler(Handler& h)
> : wait_op(&wait_handler::do_complete),
> handler_(static_cast<Handler&&>(h))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> wait_handler* h(static_cast<wait_handler*>(base));
> ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
> handler_work<Handler> w(h->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder1<Handler, boost::system::error_code>
> handler(h->handler_, h->ec_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 86 "/usr/include/boost/asio/detail/wait_handler.hpp" 2 3 4
># 32 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 40 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Time_Traits>
>class deadline_timer_service
> : public service_base<deadline_timer_service<Time_Traits> >
>{
>public:
>
> typedef typename Time_Traits::time_type time_type;
>
>
> typedef typename Time_Traits::duration_type duration_type;
>
>
>
> struct implementation_type
> : private boost::asio::detail::noncopyable
> {
> time_type expiry;
> bool might_have_pending_waits;
> typename timer_queue<Time_Traits>::per_timer_data timer_data;
> };
>
>
> deadline_timer_service(boost::asio::io_context& io_context)
> : service_base<deadline_timer_service<Time_Traits> >(io_context),
> scheduler_(boost::asio::use_service<timer_scheduler>(io_context))
> {
> scheduler_.init_task();
> scheduler_.add_timer_queue(timer_queue_);
> }
>
>
> ~deadline_timer_service()
> {
> scheduler_.remove_timer_queue(timer_queue_);
> }
>
>
> void shutdown()
> {
> }
>
>
> void construct(implementation_type& impl)
> {
> impl.expiry = time_type();
> impl.might_have_pending_waits = false;
> }
>
>
> void destroy(implementation_type& impl)
> {
> boost::system::error_code ec;
> cancel(impl, ec);
> }
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> scheduler_.move_timer(timer_queue_, impl.timer_data, other_impl.timer_data);
>
> impl.expiry = other_impl.expiry;
> other_impl.expiry = time_type();
>
> impl.might_have_pending_waits = other_impl.might_have_pending_waits;
> other_impl.might_have_pending_waits = false;
> }
>
>
> void move_assign(implementation_type& impl,
> deadline_timer_service& other_service,
> implementation_type& other_impl)
> {
> if (this != &other_service)
> if (impl.might_have_pending_waits)
> scheduler_.cancel_timer(timer_queue_, impl.timer_data);
>
> other_service.scheduler_.move_timer(other_service.timer_queue_,
> impl.timer_data, other_impl.timer_data);
>
> impl.expiry = other_impl.expiry;
> other_impl.expiry = time_type();
>
> impl.might_have_pending_waits = other_impl.might_have_pending_waits;
> other_impl.might_have_pending_waits = false;
> }
>
>
> std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
> {
> if (!impl.might_have_pending_waits)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
> (void)0
> ;
>
> std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
> impl.might_have_pending_waits = false;
> ec = boost::system::error_code();
> return count;
> }
>
>
> std::size_t cancel_one(implementation_type& impl,
> boost::system::error_code& ec)
> {
> if (!impl.might_have_pending_waits)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
> (void)0
> ;
>
> std::size_t count = scheduler_.cancel_timer(
> timer_queue_, impl.timer_data, 1);
> if (count == 0)
> impl.might_have_pending_waits = false;
> ec = boost::system::error_code();
> return count;
> }
>
>
> time_type expiry(const implementation_type& impl) const
> {
> return impl.expiry;
> }
>
>
> time_type expires_at(const implementation_type& impl) const
> {
> return impl.expiry;
> }
>
>
> duration_type expires_from_now(const implementation_type& impl) const
> {
> return Time_Traits::subtract(this->expiry(impl), Time_Traits::now());
> }
>
>
> std::size_t expires_at(implementation_type& impl,
> const time_type& expiry_time, boost::system::error_code& ec)
> {
> std::size_t count = cancel(impl, ec);
> impl.expiry = expiry_time;
> ec = boost::system::error_code();
> return count;
> }
>
>
> std::size_t expires_after(implementation_type& impl,
> const duration_type& expiry_time, boost::system::error_code& ec)
> {
> return expires_at(impl,
> Time_Traits::add(Time_Traits::now(), expiry_time), ec);
> }
>
>
> std::size_t expires_from_now(implementation_type& impl,
> const duration_type& expiry_time, boost::system::error_code& ec)
> {
> return expires_at(impl,
> Time_Traits::add(Time_Traits::now(), expiry_time), ec);
> }
>
>
> void wait(implementation_type& impl, boost::system::error_code& ec)
> {
> time_type now = Time_Traits::now();
> ec = boost::system::error_code();
> while (Time_Traits::less_than(now, impl.expiry) && !ec)
> {
> this->do_wait(Time_Traits::to_posix_duration(
> Time_Traits::subtract(impl.expiry, now)), ec);
> now = Time_Traits::now();
> }
> }
>
>
> template <typename Handler>
> void async_wait(implementation_type& impl, Handler& handler)
> {
>
> typedef wait_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> impl.might_have_pending_waits = true;
>
> (void)0
> ;
>
> scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
> p.v = p.p = 0;
> }
>
>private:
>
>
>
> template <typename Duration>
> void do_wait(const Duration& timeout, boost::system::error_code& ec)
> {
>
>
>
>
>
>
> ::timeval tv;
> tv.tv_sec = timeout.total_seconds();
> tv.tv_usec = timeout.total_microseconds() % 1000000;
> socket_ops::select(0, 0, 0, 0, &tv, ec);
>
> }
>
>
> timer_queue<Time_Traits> timer_queue_;
>
>
> timer_scheduler& scheduler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 279 "/usr/include/boost/asio/detail/deadline_timer_service.hpp" 2 3 4
># 34 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 38 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 130 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
>template <typename Time,
> typename TimeTraits = boost::asio::time_traits<Time>
> >
>class basic_deadline_timer
> : protected basic_io_object<detail::deadline_timer_service<TimeTraits> >
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
> typedef TimeTraits traits_type;
>
>
> typedef typename traits_type::time_type time_type;
>
>
> typedef typename traits_type::duration_type duration_type;
># 158 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> explicit basic_deadline_timer(boost::asio::io_context& io_context)
> : basic_io_object<detail::deadline_timer_service<TimeTraits> >(io_context)
> {
> }
># 173 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> basic_deadline_timer(boost::asio::io_context& io_context,
> const time_type& expiry_time)
> : basic_io_object<detail::deadline_timer_service<TimeTraits> >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().expires_at(this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> }
># 192 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> basic_deadline_timer(boost::asio::io_context& io_context,
> const duration_type& expiry_time)
> : basic_io_object<detail::deadline_timer_service<TimeTraits> >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().expires_from_now(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> }
># 213 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> basic_deadline_timer(basic_deadline_timer&& other)
> : basic_io_object<detail::deadline_timer_service<TimeTraits> >(std::move(other))
> {
> }
># 229 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> basic_deadline_timer& operator=(basic_deadline_timer&& other)
> {
> basic_io_object<detail::deadline_timer_service<TimeTraits> >::operator=(std::move(other));
> return *this;
> }
>
>
>
>
>
>
>
> ~basic_deadline_timer()
> {
> }
># 258 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<detail::deadline_timer_service<TimeTraits> >::get_io_context();
> }
># 272 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<detail::deadline_timer_service<TimeTraits> >::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<detail::deadline_timer_service<TimeTraits> >::get_executor();
> }
># 307 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel()
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> return s;
> }
># 337 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel(boost::system::error_code& ec)
> {
> return this->get_service().cancel(this->get_implementation(), ec);
> }
># 366 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel_one()
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().cancel_one(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel_one");
> return s;
> }
># 399 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t cancel_one(boost::system::error_code& ec)
> {
> return this->get_service().cancel_one(this->get_implementation(), ec);
> }
>
>
>
>
>
>
> time_type expires_at() const
> {
> return this->get_service().expires_at(this->get_implementation());
> }
># 436 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_at(const time_type& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().expires_at(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> return s;
> }
># 467 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_at(const time_type& expiry_time,
> boost::system::error_code& ec)
> {
> return this->get_service().expires_at(
> this->get_implementation(), expiry_time, ec);
> }
>
>
>
>
>
>
> duration_type expires_from_now() const
> {
> return this->get_service().expires_from_now(this->get_implementation());
> }
># 506 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_from_now(const duration_type& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().expires_from_now(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> return s;
> }
># 537 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> std::size_t expires_from_now(const duration_type& expiry_time,
> boost::system::error_code& ec)
> {
> return this->get_service().expires_from_now(
> this->get_implementation(), expiry_time, ec);
> }
># 551 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> void wait()
> {
> boost::system::error_code ec;
> this->get_service().wait(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 565 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> void wait(boost::system::error_code& ec)
> {
> this->get_service().wait(this->get_implementation(), ec);
> }
># 594 "/usr/include/boost/asio/basic_deadline_timer.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type
>
> async_wait(WaitHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WaitHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_wait(this->get_implementation(),
> init.completion_handler);
>
> return init.result.get();
>
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 622 "/usr/include/boost/asio/basic_deadline_timer.hpp" 2 3 4
># 25 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/basic_raw_socket.hpp" 1 3 4
># 30 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/basic_raw_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 44 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
>template <typename Protocol
> >
>class basic_raw_socket
> : public basic_socket<Protocol >
>{
>public:
>
>
>
>
> typedef typename basic_socket<
> Protocol >::native_handle_type native_handle_type;
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 73 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> explicit basic_raw_socket(boost::asio::io_context& io_context)
> : basic_socket<Protocol >(io_context)
> {
> }
># 90 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol)
> : basic_socket<Protocol >(io_context, protocol)
> {
> }
># 112 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(boost::asio::io_context& io_context,
> const endpoint_type& endpoint)
> : basic_socket<Protocol >(io_context, endpoint)
> {
> }
># 133 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol >(
> io_context, protocol, native_socket)
> {
> }
># 151 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket(basic_raw_socket&& other)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 166 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> basic_raw_socket& operator=(basic_raw_socket&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
># 182 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename Protocol1 >
> basic_raw_socket(basic_raw_socket<Protocol1 >&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 199 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename Protocol1 >
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_raw_socket>::type& operator=(
> basic_raw_socket<Protocol1 >&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
>
>
>
>
>
>
>
> ~basic_raw_socket()
> {
> }
># 239 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 265 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 292 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 335 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 387 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(this->get_implementation(),
> buffers, flags, init.completion_handler);
>
> return init.result.get();
>
> }
># 437 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, 0, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 464 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send_to(
> this->get_implementation(), buffers, destination, flags, ec);
> boost::asio::detail::throw_error(ec, "send_to");
> return s;
> }
># 491 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().send_to(this->get_implementation(),
> buffers, destination, flags, ec);
> }
># 537 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send_to(this->get_implementation(),
> buffers, destination, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 589 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send_to(const ConstBufferSequence& buffers,
> const endpoint_type& destination, socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send_to(
> this->get_implementation(), buffers, destination, flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 640 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 668 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 697 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> }
># 741 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 793 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, flags, init.completion_handler);
>
> return init.result.get();
>
> }
># 844 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 871 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags, ec);
> boost::asio::detail::throw_error(ec, "receive_from");
> return s;
> }
># 898 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> boost::system::error_code& ec)
> {
> return this->get_service().receive_from(this->get_implementation(),
> buffers, sender_endpoint, flags, ec);
> }
># 943 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, 0,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 999 "/usr/include/boost/asio/basic_raw_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive_from(const MutableBufferSequence& buffers,
> endpoint_type& sender_endpoint, socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive_from(
> this->get_implementation(), buffers, sender_endpoint, flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1031 "/usr/include/boost/asio/basic_raw_socket.hpp" 2 3 4
># 27 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 1 3 4
># 29 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 43 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
>template <typename Protocol
> >
>class basic_seq_packet_socket
> : public basic_socket<Protocol >
>{
>public:
>
>
>
>
> typedef typename basic_socket<
> Protocol >::native_handle_type native_handle_type;
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 73 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> explicit basic_seq_packet_socket(boost::asio::io_context& io_context)
> : basic_socket<Protocol >(io_context)
> {
> }
># 92 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol)
> : basic_socket<Protocol >(io_context, protocol)
> {
> }
># 114 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(boost::asio::io_context& io_context,
> const endpoint_type& endpoint)
> : basic_socket<Protocol >(io_context, endpoint)
> {
> }
># 135 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol >(
> io_context, protocol, native_socket)
> {
> }
># 154 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket(basic_seq_packet_socket&& other)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 170 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
># 188 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename Protocol1 >
> basic_seq_packet_socket(
> basic_seq_packet_socket<Protocol1 >&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 208 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename Protocol1 >
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_seq_packet_socket>::type& operator=(
> basic_seq_packet_socket<Protocol1 >&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
>
>
>
>
>
>
>
> ~basic_seq_packet_socket()
> {
> }
># 250 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 279 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 320 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(this->get_implementation(),
> buffers, flags, init.completion_handler);
>
> return init.result.get();
>
> }
># 374 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags& out_flags)
> {
> boost::system::error_code ec;
>
>
>
>
> std::size_t s = this->get_service().receive_with_flags(
> this->get_implementation(), buffers, 0, out_flags, ec);
>
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 425 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags)
> {
> boost::system::error_code ec;
>
>
>
>
> std::size_t s = this->get_service().receive_with_flags(
> this->get_implementation(), buffers, in_flags, out_flags, ec);
>
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 465 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags, boost::system::error_code& ec)
> {
>
>
>
>
> return this->get_service().receive_with_flags(this->get_implementation(),
> buffers, in_flags, out_flags, ec);
>
> }
># 517 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags& out_flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive_with_flags(
> this->get_implementation(), buffers, 0, out_flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 586 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags in_flags,
> socket_base::message_flags& out_flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive_with_flags(
> this->get_implementation(), buffers, in_flags, out_flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 619 "/usr/include/boost/asio/basic_seq_packet_socket.hpp" 2 3 4
># 28 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_serial_port.hpp" 1 3 4
># 29 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_signal_set.hpp" 1 3 4
># 30 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 1 3 4
># 46 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 47 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 71 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
>template <typename Protocol
> >
>class basic_socket_acceptor
> : protected basic_io_object<detail::reactive_socket_service<Protocol> >,
> public socket_base
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
>
>
>
> typedef typename detail::reactive_socket_service<Protocol>::native_handle_type native_handle_type;
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 104 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> explicit basic_socket_acceptor(boost::asio::io_context& io_context)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> }
># 121 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(boost::asio::io_context& io_context,
> const protocol_type& protocol)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 157 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(boost::asio::io_context& io_context,
> const endpoint_type& endpoint, bool reuse_addr = true)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> boost::system::error_code ec;
> const protocol_type protocol = endpoint.protocol();
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> if (reuse_addr)
> {
> this->get_service().set_option(this->get_implementation(),
> socket_base::reuse_address(true), ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> this->get_service().listen(this->get_implementation(),
> socket_base::max_listen_connections, ec);
> boost::asio::detail::throw_error(ec, "listen");
> }
># 193 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(boost::asio::io_context& io_context,
> const protocol_type& protocol, const native_handle_type& native_acceptor)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_acceptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 214 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor(basic_socket_acceptor&& other)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(std::move(other))
> {
> }
># 229 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
> {
> basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(other));
> return *this;
> }
>
>
> template <typename Protocol1 >
> friend class basic_socket_acceptor;
># 250 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1 >
> basic_socket_acceptor(
> basic_socket_acceptor<Protocol1 >&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_io_object<detail::reactive_socket_service<Protocol> >(
> other.get_service(), other.get_implementation())
> {
> }
># 270 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1 >
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_socket_acceptor>::type& operator=(
> basic_socket_acceptor<Protocol1 >&& other)
> {
> basic_socket_acceptor tmp(std::move(other));
> basic_io_object<detail::reactive_socket_service<Protocol> >::operator=(std::move(tmp));
> return *this;
> }
># 287 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> ~basic_socket_acceptor()
> {
> }
># 304 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_context();
> }
># 318 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<detail::reactive_socket_service<Protocol> >::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<detail::reactive_socket_service<Protocol> >::get_executor();
> }
># 346 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void open(const protocol_type& protocol = protocol_type())
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), protocol, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 373 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code open(const protocol_type& protocol,
> boost::system::error_code& ec)
> {
> this->get_service().open(this->get_implementation(), protocol, ec);
> return ec;
> }
># 390 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void assign(const protocol_type& protocol,
> const native_handle_type& native_acceptor)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> protocol, native_acceptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 409 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code assign(const protocol_type& protocol,
> const native_handle_type& native_acceptor, boost::system::error_code& ec)
> {
> this->get_service().assign(this->get_implementation(),
> protocol, native_acceptor, ec);
> return ec;
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 441 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void bind(const endpoint_type& endpoint)
> {
> boost::system::error_code ec;
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> boost::asio::detail::throw_error(ec, "bind");
> }
># 471 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code bind(const endpoint_type& endpoint,
> boost::system::error_code& ec)
> {
> this->get_service().bind(this->get_implementation(), endpoint, ec);
> return ec;
> }
># 488 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void listen(int backlog = socket_base::max_listen_connections)
> {
> boost::system::error_code ec;
> this->get_service().listen(this->get_implementation(), backlog, ec);
> boost::asio::detail::throw_error(ec, "listen");
> }
># 517 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code listen(int backlog, boost::system::error_code& ec)
> {
> this->get_service().listen(this->get_implementation(), backlog, ec);
> return ec;
> }
># 533 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 562 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> this->get_service().close(this->get_implementation(), ec);
> return ec;
> }
># 587 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> native_handle_type release()
> {
> boost::system::error_code ec;
> native_handle_type s = this->get_service().release(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "release");
> return s;
> }
># 615 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> native_handle_type release(boost::system::error_code& ec)
> {
> return this->get_service().release(this->get_implementation(), ec);
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 639 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 654 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> this->get_service().cancel(this->get_implementation(), ec);
> return ec;
> }
># 681 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SettableSocketOption>
> void set_option(const SettableSocketOption& option)
> {
> boost::system::error_code ec;
> this->get_service().set_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
># 715 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename SettableSocketOption>
> boost::system::error_code set_option(const SettableSocketOption& option,
> boost::system::error_code& ec)
> {
> this->get_service().set_option(this->get_implementation(), option, ec);
> return ec;
> }
># 745 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename GettableSocketOption>
> void get_option(GettableSocketOption& option)
> {
> boost::system::error_code ec;
> this->get_service().get_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "get_option");
> }
># 780 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename GettableSocketOption>
> boost::system::error_code get_option(GettableSocketOption& option,
> boost::system::error_code& ec)
> {
> this->get_service().get_option(this->get_implementation(), option, ec);
> return ec;
> }
># 808 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename IoControlCommand>
> void io_control(IoControlCommand& command)
> {
> boost::system::error_code ec;
> this->get_service().io_control(this->get_implementation(), command, ec);
> boost::asio::detail::throw_error(ec, "io_control");
> }
># 841 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename IoControlCommand>
> boost::system::error_code io_control(IoControlCommand& command,
> boost::system::error_code& ec)
> {
> this->get_service().io_control(this->get_implementation(), command, ec);
> return ec;
> }
># 860 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> bool non_blocking() const
> {
> return this->get_service().non_blocking(this->get_implementation());
> }
># 878 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "non_blocking");
> }
># 898 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> return ec;
> }
># 919 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> bool native_non_blocking() const
> {
> return this->get_service().native_non_blocking(this->get_implementation());
> }
># 939 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void native_non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "native_non_blocking");
> }
># 962 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code native_non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> return ec;
> }
># 985 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> endpoint_type local_endpoint() const
> {
> boost::system::error_code ec;
> endpoint_type ep = this->get_service().local_endpoint(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "local_endpoint");
> return ep;
> }
># 1016 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> endpoint_type local_endpoint(boost::system::error_code& ec) const
> {
> return this->get_service().local_endpoint(this->get_implementation(), ec);
> }
># 1037 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void wait(wait_type w)
> {
> boost::system::error_code ec;
> this->get_service().wait(this->get_implementation(), w, ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 1063 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code wait(wait_type w, boost::system::error_code& ec)
> {
> this->get_service().wait(this->get_implementation(), w, ec);
> return ec;
> }
># 1107 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type
>
> async_wait(wait_type w, WaitHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WaitHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_wait(this->get_implementation(),
> w, init.completion_handler);
>
> return init.result.get();
>
> }
># 1154 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1>
> void accept(basic_socket<Protocol1>& peer,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
>
> {
> boost::system::error_code ec;
> this->get_service().accept(this->get_implementation(),
> peer, static_cast<endpoint_type*>(0), ec);
> boost::asio::detail::throw_error(ec, "accept");
> }
># 1195 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1>
> boost::system::error_code accept(
> basic_socket<Protocol1>& peer, boost::system::error_code& ec,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
>
> {
> this->get_service().accept(this->get_implementation(),
> peer, static_cast<endpoint_type*>(0), ec);
> return ec;
> }
># 1252 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename Protocol1, typename AcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void (boost::system::error_code)>::return_type
>
> async_accept(basic_socket<Protocol1>& peer,
> AcceptHandler&& handler,
> typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
>
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<AcceptHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_accept(this->get_implementation(),
> peer, static_cast<endpoint_type*>(0), init.completion_handler);
>
> return init.result.get();
>
> }
># 1307 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> void accept(basic_socket<protocol_type>& peer, endpoint_type& peer_endpoint)
>
> {
> boost::system::error_code ec;
> this->get_service().accept(this->get_implementation(),
> peer, &peer_endpoint, ec);
> boost::asio::detail::throw_error(ec, "accept");
> }
># 1350 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> boost::system::error_code accept(basic_socket<protocol_type>& peer,
> endpoint_type& peer_endpoint, boost::system::error_code& ec)
>
> {
> this->get_service().accept(
> this->get_implementation(), peer, &peer_endpoint, ec);
> return ec;
> }
># 1392 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename AcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void (boost::system::error_code)>::return_type
>
> async_accept(basic_socket<protocol_type>& peer,
> endpoint_type& peer_endpoint, AcceptHandler&& handler)
>
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<AcceptHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "AcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<AcceptHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_accept(this->get_implementation(),
> peer, &peer_endpoint, init.completion_handler);
>
> return init.result.get();
>
> }
># 1439 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept()
> {
> boost::system::error_code ec;
> typename Protocol::socket peer(
> this->get_service().accept(
> this->get_implementation(), 0, 0, ec));
> boost::asio::detail::throw_error(ec, "accept");
> return peer;
> }
># 1474 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(boost::system::error_code& ec)
> {
> return this->get_service().accept(this->get_implementation(), 0, 0, ec);
> }
># 1517 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename MoveAcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type
>
> async_accept(MoveAcceptHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
> type_check;
>
>
>
>
>
>
>
> async_completion<MoveAcceptHandler,
> void (boost::system::error_code,
> typename Protocol::socket)> init(handler);
>
> this->get_service().async_accept(
> this->get_implementation(), static_cast<boost::asio::io_context*>(0),
> static_cast<endpoint_type*>(0), init.completion_handler);
>
> return init.result.get();
>
> }
># 1568 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(boost::asio::io_context& io_context)
> {
> boost::system::error_code ec;
> typename Protocol::socket peer(
> this->get_service().accept(this->get_implementation(),
> &io_context, static_cast<endpoint_type*>(0), ec));
> boost::asio::detail::throw_error(ec, "accept");
> return peer;
> }
># 1606 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(
> boost::asio::io_context& io_context, boost::system::error_code& ec)
> {
> return this->get_service().accept(this->get_implementation(),
> &io_context, static_cast<endpoint_type*>(0), ec);
> }
># 1654 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename MoveAcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type
>
> async_accept(boost::asio::io_context& io_context,
> MoveAcceptHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
> type_check;
>
>
>
>
>
>
> async_completion<MoveAcceptHandler,
> void (boost::system::error_code,
> typename Protocol::socket)> init(handler);
>
> this->get_service().async_accept(this->get_implementation(),
> &io_context, static_cast<endpoint_type*>(0), init.completion_handler);
>
> return init.result.get();
>
> }
># 1705 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(endpoint_type& peer_endpoint)
> {
> boost::system::error_code ec;
> typename Protocol::socket peer(
> this->get_service().accept(this->get_implementation(),
> static_cast<boost::asio::io_context*>(0), &peer_endpoint, ec));
> boost::asio::detail::throw_error(ec, "accept");
> return peer;
> }
># 1744 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(
> endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return this->get_service().accept(this->get_implementation(),
> static_cast<boost::asio::io_context*>(0), &peer_endpoint, ec);
> }
># 1795 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename MoveAcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type
>
> async_accept(endpoint_type& peer_endpoint,
> MoveAcceptHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
> type_check;
>
>
>
>
>
>
> async_completion<MoveAcceptHandler,
> void (boost::system::error_code,
> typename Protocol::socket)> init(handler);
>
> this->get_service().async_accept(this->get_implementation(),
> static_cast<boost::asio::io_context*>(0), &peer_endpoint,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 1851 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(
> boost::asio::io_context& io_context, endpoint_type& peer_endpoint)
> {
> boost::system::error_code ec;
> typename Protocol::socket peer(
> this->get_service().accept(this->get_implementation(),
> &io_context, &peer_endpoint, ec));
> boost::asio::detail::throw_error(ec, "accept");
> return peer;
> }
># 1895 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> typename Protocol::socket accept(boost::asio::io_context& io_context,
> endpoint_type& peer_endpoint, boost::system::error_code& ec)
> {
> return this->get_service().accept(this->get_implementation(),
> &io_context, &peer_endpoint, ec);
> }
># 1949 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 3 4
> template <typename MoveAcceptHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void (boost::system::error_code, typename Protocol::socket)>::return_type
>
> async_accept(boost::asio::io_context& io_context,
> endpoint_type& peer_endpoint,
> MoveAcceptHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<MoveAcceptHandler>::type, void(boost::system::error_code, typename Protocol::socket)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_move_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<typename Protocol::socket*>(0))) == 1, "MoveAcceptHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::rvref<typename Protocol::socket>()), char(0))> __attribute__((__unused__))
> type_check;
>
>
>
>
>
>
> async_completion<MoveAcceptHandler,
> void (boost::system::error_code,
> typename Protocol::socket)> init(handler);
>
> this->get_service().async_accept(this->get_implementation(),
> &io_context, &peer_endpoint, init.completion_handler);
>
> return init.result.get();
>
> }
>
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1983 "/usr/include/boost/asio/basic_socket_acceptor.hpp" 2 3 4
># 31 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_socket_iostream.hpp" 1 3 4
># 24 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
># 1 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 1 3 4
># 25 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
># 1 "/usr/include/boost/asio/basic_stream_socket.hpp" 1 3 4
># 30 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/basic_stream_socket.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 47 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
>template <typename Protocol
> >
>class basic_stream_socket
> : public basic_socket<Protocol >
>{
>public:
>
>
>
>
> typedef typename basic_socket<
> Protocol >::native_handle_type native_handle_type;
>
>
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
># 76 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> explicit basic_stream_socket(boost::asio::io_context& io_context)
> : basic_socket<Protocol >(io_context)
> {
> }
># 93 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol)
> : basic_socket<Protocol >(io_context, protocol)
> {
> }
># 114 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(boost::asio::io_context& io_context,
> const endpoint_type& endpoint)
> : basic_socket<Protocol >(io_context, endpoint)
> {
> }
># 134 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(boost::asio::io_context& io_context,
> const protocol_type& protocol, const native_handle_type& native_socket)
> : basic_socket<Protocol >(
> io_context, protocol, native_socket)
> {
> }
># 152 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket(basic_stream_socket&& other)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 167 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> basic_stream_socket& operator=(basic_stream_socket&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
># 184 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename Protocol1 >
> basic_stream_socket(
> basic_stream_socket<Protocol1 >&& other,
> typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
> : basic_socket<Protocol >(std::move(other))
> {
> }
># 202 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename Protocol1 >
> typename enable_if<is_convertible<Protocol1, Protocol>::value,
> basic_stream_socket>::type& operator=(
> basic_stream_socket<Protocol1 >&& other)
> {
> basic_socket<Protocol >::operator=(std::move(other));
> return *this;
> }
>
>
>
>
>
>
>
> ~basic_stream_socket()
> {
> }
># 246 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 283 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "send");
> return s;
> }
># 312 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().send(
> this->get_implementation(), buffers, flags, ec);
> }
># 355 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(
> this->get_implementation(), buffers, 0,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 418 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_send(const ConstBufferSequence& buffers,
> socket_base::message_flags flags,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(
> this->get_implementation(), buffers, flags,
> init.completion_handler);
>
> return init.result.get();
>
> }
># 473 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 513 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> boost::asio::detail::throw_error(ec, "receive");
> return s;
> }
># 542 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags, boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, flags, ec);
> }
># 587 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 650 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_receive(const MutableBufferSequence& buffers,
> socket_base::message_flags flags,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, flags, init.completion_handler);
>
> return init.result.get();
>
> }
># 702 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().send(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return s;
> }
># 728 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().send(this->get_implementation(), buffers, 0, ec);
> }
># 770 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_send(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
># 822 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return s;
> }
># 849 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().receive(
> this->get_implementation(), buffers, 0, ec);
> }
># 893 "/usr/include/boost/asio/basic_stream_socket.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_receive(this->get_implementation(),
> buffers, 0, init.completion_handler);
>
> return init.result.get();
>
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 922 "/usr/include/boost/asio/basic_stream_socket.hpp" 2 3 4
># 26 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
># 81 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 82 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>class socket_streambuf_io_context
>{
>protected:
> socket_streambuf_io_context(io_context* ctx)
> : default_io_context_(ctx)
> {
> }
>
> shared_ptr<io_context> default_io_context_;
>};
>
>
>
>
>
>
>class socket_streambuf_buffers
>{
>protected:
> socket_streambuf_buffers()
> : get_buffer_(buffer_size),
> put_buffer_(buffer_size)
> {
> }
>
> enum { buffer_size = 512 };
> std::vector<char> get_buffer_;
> std::vector<char> put_buffer_;
>};
>
>}
>
>
>
>
>
>template <typename Protocol
> ,
>
> typename Clock = boost::posix_time::ptime,
> typename WaitTraits = time_traits<Clock>
> >
>
>
>
>
>
>class basic_socket_streambuf;
># 146 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
>template <typename Protocol ,
> typename Clock, typename WaitTraits >
>
>class basic_socket_streambuf
> : public std::streambuf,
> private detail::socket_streambuf_io_context,
> private detail::socket_streambuf_buffers,
>
>
>
> public basic_socket<Protocol >
>
>{
>private:
>
>
>
> typedef WaitTraits traits_helper;
>
>
>
>
>public:
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef Clock clock_type;
># 192 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> typedef typename traits_helper::time_type time_type;
> typedef typename traits_helper::duration_type duration_type;
>
> typedef typename traits_helper::time_type time_point;
> typedef typename traits_helper::duration_type duration;
>
>
>
> basic_socket_streambuf()
> : detail::socket_streambuf_io_context(new io_context),
> basic_socket<Protocol >(*default_io_context_),
> expiry_time_(max_expiry_time())
> {
> init_buffers();
> }
>
>
>
> explicit basic_socket_streambuf(basic_stream_socket<protocol_type> s)
> : detail::socket_streambuf_io_context(0),
> basic_socket<Protocol >(std::move(s)),
> expiry_time_(max_expiry_time())
> {
> init_buffers();
> }
>
>
> basic_socket_streambuf(basic_socket_streambuf&& other)
> : detail::socket_streambuf_io_context(other),
> basic_socket<Protocol >(std::move(other.socket())),
> ec_(other.ec_),
> expiry_time_(other.expiry_time_)
> {
> get_buffer_.swap(other.get_buffer_);
> put_buffer_.swap(other.put_buffer_);
> setg(other.eback(), other.gptr(), other.egptr());
> setp(other.pptr(), other.epptr());
> other.ec_ = boost::system::error_code();
> other.expiry_time_ = max_expiry_time();
> other.init_buffers();
> }
>
>
> basic_socket_streambuf& operator=(basic_socket_streambuf&& other)
> {
> this->close();
> socket() = std::move(other.socket());
> detail::socket_streambuf_io_context::operator=(other);
> ec_ = other.ec_;
> expiry_time_ = other.expiry_time_;
> get_buffer_.swap(other.get_buffer_);
> put_buffer_.swap(other.put_buffer_);
> setg(other.eback(), other.gptr(), other.egptr());
> setp(other.pptr(), other.epptr());
> other.ec_ = boost::system::error_code();
> other.expiry_time_ = max_expiry_time();
> other.put_buffer_.resize(buffer_size);
> other.init_buffers();
> return *this;
> }
>
>
>
> virtual ~basic_socket_streambuf()
> {
> if (pptr() != pbase())
> overflow(traits_type::eof());
> }
># 268 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> basic_socket_streambuf* connect(const endpoint_type& endpoint)
> {
> init_buffers();
> ec_ = boost::system::error_code();
> this->connect_to_endpoints(&endpoint, &endpoint + 1);
> return !ec_ ? this : 0;
> }
># 289 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> template <typename... T>
> basic_socket_streambuf* connect(T... x)
> {
> init_buffers();
> typedef typename Protocol::resolver resolver_type;
> resolver_type resolver(socket().get_executor().context());
> connect_to_endpoints(resolver.resolve(x..., ec_));
> return !ec_ ? this : 0;
> }
># 307 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> basic_socket_streambuf* close()
> {
> sync();
> socket().close(ec_);
> if (!ec_)
> init_buffers();
> return !ec_ ? this : 0;
> }
>
>
> basic_socket<Protocol >& socket()
> {
> return *this;
> }
>
>
>
>
>
>
> const boost::system::error_code& error() const
> {
> return ec_;
> }
># 339 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> const boost::system::error_code& puberror() const
> {
> return error();
> }
>
>
>
>
>
>
>
> time_point expires_at() const
> {
> return expiry_time_;
> }
>
>
>
>
>
>
>
> time_point expiry() const
> {
> return expiry_time_;
> }
># 375 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> void expires_at(const time_point& expiry_time)
> {
> expiry_time_ = expiry_time;
> }
># 389 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> void expires_after(const duration& expiry_time)
> {
> expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
> }
>
>
>
>
>
>
>
> duration expires_from_now() const
> {
> return traits_helper::subtract(expires_at(), traits_helper::now());
> }
># 415 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 3 4
> void expires_from_now(const duration& expiry_time)
> {
> expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
> }
>
>
>protected:
> int_type underflow()
> {
>
>
>
>
> if (gptr() != egptr())
> return traits_type::eof();
>
> for (;;)
> {
>
> if (traits_helper::less_than(expiry_time_, traits_helper::now()))
> {
> ec_ = boost::asio::error::timed_out;
> return traits_type::eof();
> }
>
>
> if (!socket().native_non_blocking())
> socket().native_non_blocking(true, ec_);
> detail::buffer_sequence_adapter<mutable_buffer, mutable_buffer>
> bufs(boost::asio::buffer(get_buffer_) + putback_max);
> detail::signed_size_type bytes = detail::socket_ops::recv(
> socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
>
>
> if (bytes > 0)
> {
> setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
> &get_buffer_[0] + putback_max + bytes);
> return traits_type::to_int_type(*gptr());
> }
>
>
> if (bytes == 0)
> {
> ec_ = boost::asio::error::eof;
> return traits_type::eof();
> }
>
>
> if (ec_ != boost::asio::error::would_block
> && ec_ != boost::asio::error::try_again)
> return traits_type::eof();
>
>
> if (detail::socket_ops::poll_read(
> socket().native_handle(), 0, timeout(), ec_) < 0)
> return traits_type::eof();
> }
>
> }
>
> int_type overflow(int_type c)
> {
>
>
>
>
> char_type ch = traits_type::to_char_type(c);
>
>
> const_buffer output_buffer;
> if (put_buffer_.empty())
> {
> if (traits_type::eq_int_type(c, traits_type::eof()))
> return traits_type::not_eof(c);
> output_buffer = boost::asio::buffer(&ch, sizeof(char_type));
> }
> else
> {
> output_buffer = boost::asio::buffer(pbase(),
> (pptr() - pbase()) * sizeof(char_type));
> }
>
> while (output_buffer.size() > 0)
> {
>
> if (traits_helper::less_than(expiry_time_, traits_helper::now()))
> {
> ec_ = boost::asio::error::timed_out;
> return traits_type::eof();
> }
>
>
> if (!socket().native_non_blocking())
> socket().native_non_blocking(true, ec_);
> detail::buffer_sequence_adapter<
> const_buffer, const_buffer> bufs(output_buffer);
> detail::signed_size_type bytes = detail::socket_ops::send(
> socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
>
>
> if (bytes > 0)
> {
> output_buffer += static_cast<std::size_t>(bytes);
> continue;
> }
>
>
> if (ec_ != boost::asio::error::would_block
> && ec_ != boost::asio::error::try_again)
> return traits_type::eof();
>
>
> if (detail::socket_ops::poll_write(
> socket().native_handle(), 0, timeout(), ec_) < 0)
> return traits_type::eof();
> }
>
> if (!put_buffer_.empty())
> {
> setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
>
>
> if (traits_type::eq_int_type(c, traits_type::eof()))
> return traits_type::not_eof(c);
>
>
> *pptr() = ch;
> pbump(1);
> }
>
> return c;
>
> }
>
> int sync()
> {
> return overflow(traits_type::eof());
> }
>
> std::streambuf* setbuf(char_type* s, std::streamsize n)
> {
> if (pptr() == pbase() && s == 0 && n == 0)
> {
> put_buffer_.clear();
> setp(0, 0);
> sync();
> return this;
> }
>
> return 0;
> }
>
>private:
>
> basic_socket_streambuf(const basic_socket_streambuf&) = delete;
> basic_socket_streambuf& operator=(
> const basic_socket_streambuf&) = delete;
>
> void init_buffers()
> {
> setg(&get_buffer_[0],
> &get_buffer_[0] + putback_max,
> &get_buffer_[0] + putback_max);
>
> if (put_buffer_.empty())
> setp(0, 0);
> else
> setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
> }
>
> int timeout() const
> {
> int64_t msec = traits_helper::to_posix_duration(
> traits_helper::subtract(expiry_time_,
> traits_helper::now())).total_milliseconds();
> if (msec > (std::numeric_limits<int>::max)())
> msec = (std::numeric_limits<int>::max)();
> else if (msec < 0)
> msec = 0;
> return static_cast<int>(msec);
> }
>
> template <typename EndpointSequence>
> void connect_to_endpoints(const EndpointSequence& endpoints)
> {
> this->connect_to_endpoints(endpoints.begin(), endpoints.end());
> }
>
> template <typename EndpointIterator>
> void connect_to_endpoints(EndpointIterator begin, EndpointIterator end)
> {
>
>
>
> if (ec_)
> return;
>
> ec_ = boost::asio::error::not_found;
> for (EndpointIterator i = begin; i != end; ++i)
> {
>
> if (traits_helper::less_than(expiry_time_, traits_helper::now()))
> {
> ec_ = boost::asio::error::timed_out;
> return;
> }
>
>
> typename Protocol::endpoint ep(*i);
> socket().close(ec_);
> socket().open(ep.protocol(), ec_);
> if (ec_)
> continue;
>
>
> if (!socket().native_non_blocking())
> socket().native_non_blocking(true, ec_);
> detail::socket_ops::connect(socket().native_handle(),
> ep.data(), ep.size(), ec_);
>
>
> if (!ec_)
> return;
>
>
> if (ec_ != boost::asio::error::in_progress
> && ec_ != boost::asio::error::would_block)
> continue;
>
>
> if (detail::socket_ops::poll_connect(
> socket().native_handle(), timeout(), ec_) < 0)
> continue;
>
>
> int connect_error = 0;
> size_t connect_error_len = sizeof(connect_error);
> if (detail::socket_ops::getsockopt(socket().native_handle(), 0,
> 1, 4, &connect_error, &connect_error_len, ec_)
> == detail::socket_error_retval)
> return;
>
>
> ec_ = boost::system::error_code(connect_error,
> boost::asio::error::get_system_category());
> if (!ec_)
> return;
> }
>
> }
>
>
> static time_point max_expiry_time()
> {
>
> return boost::posix_time::pos_infin;
>
>
>
> }
>
> enum { putback_max = 8 };
> boost::system::error_code ec_;
> time_point expiry_time_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 686 "/usr/include/boost/asio/basic_socket_streambuf.hpp" 2 3 4
># 25 "/usr/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
># 81 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 82 "/usr/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>template <typename Protocol ,
> typename Clock, typename WaitTraits >
>class socket_iostream_base
>{
>protected:
> socket_iostream_base()
> {
> }
>
>
> socket_iostream_base(socket_iostream_base&& other)
> : streambuf_(std::move(other.streambuf_))
> {
> }
>
> socket_iostream_base(basic_stream_socket<Protocol> s)
> : streambuf_(std::move(s))
> {
> }
>
> socket_iostream_base& operator=(socket_iostream_base&& other)
> {
> streambuf_ = std::move(other.streambuf_);
> return *this;
> }
>
>
> basic_socket_streambuf<Protocol ,
> Clock, WaitTraits > streambuf_;
>};
>
>}
>
>
>
>
>
>template <typename Protocol
> ,
>
> typename Clock = boost::posix_time::ptime,
> typename WaitTraits = time_traits<Clock>
> >
>
>
>
>
>
>class basic_socket_iostream;
># 147 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
>template <typename Protocol ,
> typename Clock, typename WaitTraits >
>
>class basic_socket_iostream
> : private detail::socket_iostream_base<Protocol
> , Clock, WaitTraits >,
> public std::basic_iostream<char>
>{
>private:
>
>
>
> typedef WaitTraits traits_helper;
>
>
>
>
>public:
>
> typedef Protocol protocol_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef Clock clock_type;
># 188 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> typedef typename traits_helper::time_type time_type;
> typedef typename traits_helper::duration_type duration_type;
>
> typedef typename traits_helper::time_type time_point;
> typedef typename traits_helper::duration_type duration;
>
>
>
> basic_socket_iostream()
> : std::basic_iostream<char>(
> &this->detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >::streambuf_)
> {
> this->setf(std::ios_base::unitbuf);
> }
>
>
>
> explicit basic_socket_iostream(basic_stream_socket<protocol_type> s)
> : detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >(std::move(s)),
> std::basic_iostream<char>(
> &this->detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >::streambuf_)
> {
> this->setf(std::ios_base::unitbuf);
> }
>
>
>
>
> basic_socket_iostream(basic_socket_iostream&& other)
> : detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >(std::move(other)),
> std::basic_iostream<char>(std::move(other))
> {
> this->set_rdbuf(&this->detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >::streambuf_);
> }
>
>
> basic_socket_iostream& operator=(basic_socket_iostream&& other)
> {
> std::basic_iostream<char>::operator=(std::move(other));
> detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >::operator=(std::move(other));
> return *this;
> }
># 256 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> template <typename... T>
> explicit basic_socket_iostream(T... x)
> : std::basic_iostream<char>(
> &this->detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >::streambuf_)
> {
> this->setf(std::ios_base::unitbuf);
> if (rdbuf()->connect(x...) == 0)
> this->setstate(std::ios_base::failbit);
> }
># 281 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> template <typename... T>
> void connect(T... x)
> {
> if (rdbuf()->connect(x...) == 0)
> this->setstate(std::ios_base::failbit);
> }
>
>
>
>
>
> void close()
> {
> if (rdbuf()->close() == 0)
> this->setstate(std::ios_base::failbit);
> }
>
>
> basic_socket_streambuf<Protocol ,
> Clock, WaitTraits >* rdbuf() const
> {
> return const_cast<basic_socket_streambuf<Protocol ,
> Clock, WaitTraits >*>(
> &this->detail::socket_iostream_base<
> Protocol , Clock,
> WaitTraits >::streambuf_);
> }
>
>
> basic_socket<Protocol >& socket()
> {
> return rdbuf()->socket();
> }
># 327 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> const boost::system::error_code& error() const
> {
> return rdbuf()->error();
> }
>
>
>
>
>
>
>
> time_point expires_at() const
> {
> return rdbuf()->expires_at();
> }
>
>
>
>
>
>
> time_point expiry() const
> {
> return rdbuf()->expiry();
> }
># 362 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> void expires_at(const time_point& expiry_time)
> {
> rdbuf()->expires_at(expiry_time);
> }
># 376 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> void expires_after(const duration& expiry_time)
> {
> rdbuf()->expires_after(expiry_time);
> }
>
>
>
>
>
>
> duration expires_from_now() const
> {
> return rdbuf()->expires_from_now();
> }
># 401 "/usr/include/boost/asio/basic_socket_iostream.hpp" 3 4
> void expires_from_now(const duration& expiry_time)
> {
> rdbuf()->expires_from_now(expiry_time);
> }
>
>
>private:
>
> basic_socket_iostream(const basic_socket_iostream&) = delete;
> basic_socket_iostream& operator=(
> const basic_socket_iostream&) = delete;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 418 "/usr/include/boost/asio/basic_socket_iostream.hpp" 2 3 4
># 32 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/basic_streambuf.hpp" 1 3 4
># 23 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 24 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/basic_streambuf_fwd.hpp" 1 3 4
># 24 "/usr/include/boost/asio/basic_streambuf_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Allocator = std::allocator<char> >
>class basic_streambuf;
>
>template <typename Allocator = std::allocator<char> >
>class basic_streambuf_ref;
>
>}
>}
># 28 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 34 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 109 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
>template <typename Allocator>
>
>class basic_streambuf
> : public std::streambuf,
> private noncopyable
>{
>public:
>
>
>
>
>
>
>
> typedef const_buffers_1 const_buffers_type;
> typedef mutable_buffers_1 mutable_buffers_type;
>
>
>
>
>
>
>
> explicit basic_streambuf(
> std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
> const Allocator& allocator = Allocator())
> : max_size_(maximum_size),
> buffer_(allocator)
> {
> std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
> buffer_.resize((std::max<std::size_t>)(pend, 1));
> setg(&buffer_[0], &buffer_[0], &buffer_[0]);
> setp(&buffer_[0], &buffer_[0] + pend);
> }
># 159 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> std::size_t size() const noexcept
> {
> return pptr() - gptr();
> }
>
>
>
>
>
>
> std::size_t max_size() const noexcept
> {
> return max_size_;
> }
>
>
>
>
>
>
> std::size_t capacity() const noexcept
> {
> return buffer_.capacity();
> }
># 193 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> const_buffers_type data() const noexcept
> {
> return boost::asio::buffer(boost::asio::const_buffer(gptr(),
> (pptr() - gptr()) * sizeof(char_type)));
> }
># 215 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> mutable_buffers_type prepare(std::size_t n)
> {
> reserve(n);
> return boost::asio::buffer(boost::asio::mutable_buffer(
> pptr(), n * sizeof(char_type)));
> }
># 234 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> void commit(std::size_t n)
> {
> n = std::min<std::size_t>(n, epptr() - pptr());
> pbump(static_cast<int>(n));
> setg(eback(), gptr(), pptr());
> }
># 248 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> void consume(std::size_t n)
> {
> if (egptr() < pptr())
> setg(&buffer_[0], gptr(), pptr());
> if (gptr() + n > pptr())
> n = pptr() - gptr();
> gbump(static_cast<int>(n));
> }
>
>protected:
> enum { buffer_delta = 128 };
>
>
>
>
>
> int_type underflow()
> {
> if (gptr() < pptr())
> {
> setg(&buffer_[0], gptr(), pptr());
> return traits_type::to_int_type(*gptr());
> }
> else
> {
> return traits_type::eof();
> }
> }
># 284 "/usr/include/boost/asio/basic_streambuf.hpp" 3 4
> int_type overflow(int_type c)
> {
> if (!traits_type::eq_int_type(c, traits_type::eof()))
> {
> if (pptr() == epptr())
> {
> std::size_t buffer_size = pptr() - gptr();
> if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
> {
> reserve(max_size_ - buffer_size);
> }
> else
> {
> reserve(buffer_delta);
> }
> }
>
> *pptr() = traits_type::to_char_type(c);
> pbump(1);
> return c;
> }
>
> return traits_type::not_eof(c);
> }
>
> void reserve(std::size_t n)
> {
>
> std::size_t gnext = gptr() - &buffer_[0];
> std::size_t pnext = pptr() - &buffer_[0];
> std::size_t pend = epptr() - &buffer_[0];
>
>
> if (n <= pend - pnext)
> {
> return;
> }
>
>
> if (gnext > 0)
> {
> pnext -= gnext;
> std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
> }
>
>
> if (n > pend - pnext)
> {
> if (n <= max_size_ && pnext <= max_size_ - n)
> {
> pend = pnext + n;
> buffer_.resize((std::max<std::size_t>)(pend, 1));
> }
> else
> {
> std::length_error ex("boost::asio::streambuf too long");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
> setp(&buffer_[0] + pnext, &buffer_[0] + pend);
> }
>
>private:
> std::size_t max_size_;
> std::vector<char_type, Allocator> buffer_;
>
>
> friend std::size_t read_size_helper(
> basic_streambuf& sb, std::size_t max_size)
> {
> return std::min<std::size_t>(
> std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
> std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
> }
>};
>
>
>
>
>
>template <typename Allocator>
>
>class basic_streambuf_ref
>{
>public:
>
> typedef typename basic_streambuf<Allocator>::const_buffers_type
> const_buffers_type;
>
>
> typedef typename basic_streambuf<Allocator>::mutable_buffers_type
> mutable_buffers_type;
>
>
> explicit basic_streambuf_ref(basic_streambuf<Allocator>& sb)
> : sb_(sb)
> {
> }
>
>
> basic_streambuf_ref(const basic_streambuf_ref& other) noexcept
> : sb_(other.sb_)
> {
> }
>
>
>
> basic_streambuf_ref(basic_streambuf_ref&& other) noexcept
> : sb_(other.sb_)
> {
> }
>
>
>
> std::size_t size() const noexcept
> {
> return sb_.size();
> }
>
>
> std::size_t max_size() const noexcept
> {
> return sb_.max_size();
> }
>
>
> std::size_t capacity() const noexcept
> {
> return sb_.capacity();
> }
>
>
> const_buffers_type data() const noexcept
> {
> return sb_.data();
> }
>
>
>
> mutable_buffers_type prepare(std::size_t n)
> {
> return sb_.prepare(n);
> }
>
>
> void commit(std::size_t n)
> {
> return sb_.commit(n);
> }
>
>
> void consume(std::size_t n)
> {
> return sb_.consume(n);
> }
>
>private:
> basic_streambuf<Allocator>& sb_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 451 "/usr/include/boost/asio/basic_streambuf.hpp" 2 3 4
># 35 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/basic_waitable_timer.hpp" 1 3 4
># 24 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
># 1 "/usr/include/boost/asio/wait_traits.hpp" 1 3 4
># 18 "/usr/include/boost/asio/wait_traits.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 19 "/usr/include/boost/asio/wait_traits.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Clock>
>struct wait_traits
>{
>
>
>
>
> static typename Clock::duration to_wait_duration(
> const typename Clock::duration& d)
> {
> return d;
> }
>
>
>
>
>
> static typename Clock::duration to_wait_duration(
> const typename Clock::time_point& t)
> {
> typename Clock::time_point now = Clock::now();
> if (now + (Clock::duration::max)() < t)
> return (Clock::duration::max)();
> if (now + (Clock::duration::min)() > t)
> return (Clock::duration::min)();
> return t - now;
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 57 "/usr/include/boost/asio/wait_traits.hpp" 2 3 4
># 25 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
># 33 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <int64_t v1, int64_t v2>
>struct gcd { enum { value = gcd<v2, v1 % v2>::value }; };
>
>template <int64_t v1>
>struct gcd<v1, 0> { enum { value = v1 }; };
>
>
>template <typename Clock, typename WaitTraits>
>struct chrono_time_traits
>{
>
> typedef Clock clock_type;
>
>
> typedef typename clock_type::duration duration_type;
>
>
> typedef typename clock_type::time_point time_type;
>
>
> typedef typename duration_type::period period_type;
>
>
> static time_type now()
> {
> return clock_type::now();
> }
>
>
> static time_type add(const time_type& t, const duration_type& d)
> {
> const time_type epoch;
> if (t >= epoch)
> {
> if ((time_type::max)() - t < d)
> return (time_type::max)();
> }
> else
> {
> if (-(t - (time_type::min)()) > d)
> return (time_type::min)();
> }
>
> return t + d;
> }
>
>
> static duration_type subtract(const time_type& t1, const time_type& t2)
> {
> const time_type epoch;
> if (t1 >= epoch)
> {
> if (t2 >= epoch)
> {
> return t1 - t2;
> }
> else if (t2 == (time_type::min)())
> {
> return (duration_type::max)();
> }
> else if ((time_type::max)() - t1 < epoch - t2)
> {
> return (duration_type::max)();
> }
> else
> {
> return t1 - t2;
> }
> }
> else
> {
> if (t2 < epoch)
> {
> return t1 - t2;
> }
> else if (t1 == (time_type::min)())
> {
> return (duration_type::min)();
> }
> else if ((time_type::max)() - t2 < epoch - t1)
> {
> return (duration_type::min)();
> }
> else
> {
> return -(t2 - t1);
> }
> }
> }
>
>
> static bool less_than(const time_type& t1, const time_type& t2)
> {
> return t1 < t2;
> }
>
>
>
> class posix_time_duration
> {
> public:
> explicit posix_time_duration(const duration_type& d)
> : d_(d)
> {
> }
>
> int64_t ticks() const
> {
> return d_.count();
> }
>
> int64_t total_seconds() const
> {
> return duration_cast<1, 1>();
> }
>
> int64_t total_milliseconds() const
> {
> return duration_cast<1, 1000>();
> }
>
> int64_t total_microseconds() const
> {
> return duration_cast<1, 1000000>();
> }
>
> private:
> template <int64_t Num, int64_t Den>
> int64_t duration_cast() const
> {
> const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value;
> const int64_t num2 = Num / gcd<period_type::num, Num>::value;
>
> const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value;
> const int64_t den2 = Den / gcd<period_type::den, Den>::value;
>
> const int64_t num = num1 * den2;
> const int64_t den = num2 * den1;
>
> if (num == 1 && den == 1)
> return ticks();
> else if (num != 1 && den == 1)
> return ticks() * num;
> else if (num == 1 && period_type::den != 1)
> return ticks() / den;
> else
> return ticks() * num / den;
> }
>
> duration_type d_;
> };
>
>
> static posix_time_duration to_posix_duration(const duration_type& d)
> {
> return posix_time_duration(WaitTraits::to_wait_duration(d));
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 191 "/usr/include/boost/asio/detail/chrono_time_traits.hpp" 2 3 4
># 34 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 41 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>
>
>template <typename Clock,
> typename WaitTraits = boost::asio::wait_traits<Clock>
> >
>class basic_waitable_timer;
># 148 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
>template <typename Clock, typename WaitTraits >
>class basic_waitable_timer
> : protected basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
> typedef Clock clock_type;
>
>
> typedef typename clock_type::duration duration;
>
>
> typedef typename clock_type::time_point time_point;
>
>
> typedef WaitTraits traits_type;
># 177 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> explicit basic_waitable_timer(boost::asio::io_context& io_context)
> : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(io_context)
> {
> }
># 192 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> basic_waitable_timer(boost::asio::io_context& io_context,
> const time_point& expiry_time)
> : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().expires_at(this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> }
># 211 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> basic_waitable_timer(boost::asio::io_context& io_context,
> const duration& expiry_time)
> : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(io_context)
> {
> boost::system::error_code ec;
> this->get_service().expires_after(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_after");
> }
># 232 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> basic_waitable_timer(basic_waitable_timer&& other)
> : basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >(std::move(other))
> {
> }
># 248 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> basic_waitable_timer& operator=(basic_waitable_timer&& other)
> {
> basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::operator=(std::move(other));
> return *this;
> }
>
>
>
>
>
>
>
> ~basic_waitable_timer()
> {
> }
># 277 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::get_io_context();
> }
># 291 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<detail::deadline_timer_service< detail::chrono_time_traits<Clock, WaitTraits> > >::get_executor();
> }
># 326 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel()
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> return s;
> }
># 358 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel(boost::system::error_code& ec)
> {
> return this->get_service().cancel(this->get_implementation(), ec);
> }
># 388 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel_one()
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().cancel_one(
> this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel_one");
> return s;
> }
># 423 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t cancel_one(boost::system::error_code& ec)
> {
> return this->get_service().cancel_one(this->get_implementation(), ec);
> }
>
>
>
>
>
>
>
> time_point expires_at() const
> {
> return this->get_service().expires_at(this->get_implementation());
> }
>
>
>
>
>
>
>
> time_point expiry() const
> {
> return this->get_service().expiry(this->get_implementation());
> }
># 472 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_at(const time_point& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().expires_at(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_at");
> return s;
> }
># 505 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_at(const time_point& expiry_time,
> boost::system::error_code& ec)
> {
> return this->get_service().expires_at(
> this->get_implementation(), expiry_time, ec);
> }
># 535 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_after(const duration& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().expires_after(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_after");
> return s;
> }
>
>
>
>
>
>
>
> duration expires_from_now() const
> {
> return this->get_service().expires_from_now(this->get_implementation());
> }
># 578 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_from_now(const duration& expiry_time)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().expires_from_now(
> this->get_implementation(), expiry_time, ec);
> boost::asio::detail::throw_error(ec, "expires_from_now");
> return s;
> }
># 610 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> std::size_t expires_from_now(const duration& expiry_time,
> boost::system::error_code& ec)
> {
> return this->get_service().expires_from_now(
> this->get_implementation(), expiry_time, ec);
> }
># 625 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> void wait()
> {
> boost::system::error_code ec;
> this->get_service().wait(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 639 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> void wait(boost::system::error_code& ec)
> {
> this->get_service().wait(this->get_implementation(), ec);
> }
># 668 "/usr/include/boost/asio/basic_waitable_timer.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type
>
> async_wait(WaitHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
>
>
>
>
> async_completion<WaitHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_wait(this->get_implementation(),
> init.completion_handler);
>
> return init.result.get();
>
> }
>
>private:
>
> basic_waitable_timer(const basic_waitable_timer&) = delete;
> basic_waitable_timer& operator=(
> const basic_waitable_timer&) = delete;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 702 "/usr/include/boost/asio/basic_waitable_timer.hpp" 2 3 4
># 36 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/bind_executor.hpp" 1 3 4
># 26 "/usr/include/boost/asio/bind_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/uses_executor.hpp" 1 3 4
># 21 "/usr/include/boost/asio/uses_executor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/uses_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 35 "/usr/include/boost/asio/uses_executor.hpp" 3 4
>struct executor_arg_t
>{
>
> constexpr executor_arg_t() noexcept
> {
> }
>};
># 50 "/usr/include/boost/asio/uses_executor.hpp" 3 4
>constexpr executor_arg_t executor_arg;
># 65 "/usr/include/boost/asio/uses_executor.hpp" 3 4
>template <typename T, typename Executor>
>struct uses_executor : false_type {};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 72 "/usr/include/boost/asio/uses_executor.hpp" 2 3 4
># 27 "/usr/include/boost/asio/bind_executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/bind_executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename T>
>struct executor_binder_check
>{
> typedef void type;
>};
>
>
>
>template <typename T, typename = void>
>struct executor_binder_result_type
>{
>protected:
> typedef void result_type_or_void;
>};
>
>template <typename T>
>struct executor_binder_result_type<T,
> typename executor_binder_check<typename T::result_type>::type>
>{
> typedef typename T::result_type result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>template <typename R>
>struct executor_binder_result_type<R(*)()>
>{
> typedef R result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>template <typename R>
>struct executor_binder_result_type<R(&)()>
>{
> typedef R result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>template <typename R, typename A1>
>struct executor_binder_result_type<R(*)(A1)>
>{
> typedef R result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>template <typename R, typename A1>
>struct executor_binder_result_type<R(&)(A1)>
>{
> typedef R result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>template <typename R, typename A1, typename A2>
>struct executor_binder_result_type<R(*)(A1, A2)>
>{
> typedef R result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>template <typename R, typename A1, typename A2>
>struct executor_binder_result_type<R(&)(A1, A2)>
>{
> typedef R result_type;
>protected:
> typedef result_type result_type_or_void;
>};
>
>
>
>template <typename T, typename = void>
>struct executor_binder_argument_type {};
>
>template <typename T>
>struct executor_binder_argument_type<T,
> typename executor_binder_check<typename T::argument_type>::type>
>{
> typedef typename T::argument_type argument_type;
>};
>
>template <typename R, typename A1>
>struct executor_binder_argument_type<R(*)(A1)>
>{
> typedef A1 argument_type;
>};
>
>template <typename R, typename A1>
>struct executor_binder_argument_type<R(&)(A1)>
>{
> typedef A1 argument_type;
>};
>
>
>
>
>template <typename T, typename = void>
>struct executor_binder_argument_types {};
>
>template <typename T>
>struct executor_binder_argument_types<T,
> typename executor_binder_check<typename T::first_argument_type>::type>
>{
> typedef typename T::first_argument_type first_argument_type;
> typedef typename T::second_argument_type second_argument_type;
>};
>
>template <typename R, typename A1, typename A2>
>struct executor_binder_argument_type<R(*)(A1, A2)>
>{
> typedef A1 first_argument_type;
> typedef A2 second_argument_type;
>};
>
>template <typename R, typename A1, typename A2>
>struct executor_binder_argument_type<R(&)(A1, A2)>
>{
> typedef A1 first_argument_type;
> typedef A2 second_argument_type;
>};
>
>
>
>
>
>template <typename T, typename Executor, bool UsesExecutor>
>class executor_binder_base;
>
>template <typename T, typename Executor>
>class executor_binder_base<T, Executor, true>
> : protected Executor
>{
>protected:
> template <typename E, typename U>
> executor_binder_base(E&& e, U&& u)
> : executor_(static_cast<E&&>(e)),
> target_(executor_arg_t(), executor_, static_cast<U&&>(u))
> {
> }
>
> Executor executor_;
> T target_;
>};
>
>template <typename T, typename Executor>
>class executor_binder_base<T, Executor, false>
>{
>protected:
> template <typename E, typename U>
> executor_binder_base(E&& e, U&& u)
> : executor_(static_cast<E&&>(e)),
> target_(static_cast<U&&>(u))
> {
> }
>
> Executor executor_;
> T target_;
>};
>
>
>
>template <typename T, typename = void>
>struct executor_binder_result_of0
>{
> typedef void type;
>};
>
>template <typename T>
>struct executor_binder_result_of0<T,
> typename executor_binder_check<typename result_of<T()>::type>::type>
>{
> typedef typename result_of<T()>::type type;
>};
>
>}
>
>
>
>template <typename T, typename Executor>
>class executor_binder
>
> : public detail::executor_binder_result_type<T>,
> public detail::executor_binder_argument_type<T>,
> public detail::executor_binder_argument_types<T>,
> private detail::executor_binder_base<
> T, Executor, uses_executor<T, Executor>::value>
>
>{
>public:
>
> typedef T target_type;
>
>
> typedef Executor executor_type;
># 299 "/usr/include/boost/asio/bind_executor.hpp" 3 4
> template <typename U>
> executor_binder(executor_arg_t, const executor_type& e,
> U&& u)
> : base_type(e, static_cast<U&&>(u))
> {
> }
>
>
> executor_binder(const executor_binder& other)
> : base_type(other.get_executor(), other.get())
> {
> }
>
>
> executor_binder(executor_arg_t, const executor_type& e,
> const executor_binder& other)
> : base_type(e, other.get())
> {
> }
>
>
>
>
>
>
>
> template <typename U, typename OtherExecutor>
> executor_binder(const executor_binder<U, OtherExecutor>& other)
> : base_type(other.get_executor(), other.get())
> {
> }
>
>
>
>
>
>
>
> template <typename U, typename OtherExecutor>
> executor_binder(executor_arg_t, const executor_type& e,
> const executor_binder<U, OtherExecutor>& other)
> : base_type(e, other.get())
> {
> }
>
>
>
>
> executor_binder(executor_binder&& other)
> : base_type(static_cast<executor_type&&>(other.get_executor()),
> static_cast<T&&>(other.get()))
> {
> }
>
>
> executor_binder(executor_arg_t, const executor_type& e,
> executor_binder&& other)
> : base_type(e, static_cast<T&&>(other.get()))
> {
> }
>
>
> template <typename U, typename OtherExecutor>
> executor_binder(executor_binder<U, OtherExecutor>&& other)
> : base_type(static_cast<OtherExecutor&&>(other.get_executor()),
> static_cast<U&&>(other.get()))
> {
> }
>
>
>
> template <typename U, typename OtherExecutor>
> executor_binder(executor_arg_t, const executor_type& e,
> executor_binder<U, OtherExecutor>&& other)
> : base_type(e, static_cast<U&&>(other.get()))
> {
> }
>
>
>
>
> ~executor_binder()
> {
> }
>
>
> target_type& get() noexcept
> {
> return this->target_;
> }
>
>
> const target_type& get() const noexcept
> {
> return this->target_;
> }
>
>
> executor_type get_executor() const noexcept
> {
> return this->executor_;
> }
># 410 "/usr/include/boost/asio/bind_executor.hpp" 3 4
> template <typename... Args>
> typename result_of<T(Args...)>::type operator()(
> Args&&... args)
> {
> return this->target_(static_cast<Args&&>(args)...);
> }
>
>
> template <typename... Args>
> typename result_of<T(Args...)>::type operator()(
> Args&&... args) const
> {
> return this->target_(static_cast<Args&&>(args)...);
> }
># 490 "/usr/include/boost/asio/bind_executor.hpp" 3 4
>private:
> typedef detail::executor_binder_base<T, Executor,
> uses_executor<T, Executor>::value> base_type;
>};
>
>
>template <typename Executor, typename T>
>inline executor_binder<typename decay<T>::type, Executor>
>bind_executor(const Executor& ex, T&& t,
> typename enable_if<is_executor<Executor>::value>::type* = 0)
>{
> return executor_binder<typename decay<T>::type, Executor>(
> executor_arg_t(), ex, static_cast<T&&>(t));
>}
>
>
>template <typename ExecutionContext, typename T>
>inline executor_binder<typename decay<T>::type,
> typename ExecutionContext::executor_type>
>bind_executor(ExecutionContext& ctx, T&& t,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type* = 0)
>{
> return executor_binder<typename decay<T>::type,
> typename ExecutionContext::executor_type>(
> executor_arg_t(), ctx.get_executor(), static_cast<T&&>(t));
>}
>
>
>
>template <typename T, typename Executor>
>struct uses_executor<executor_binder<T, Executor>, Executor>
> : true_type {};
>
>template <typename T, typename Executor, typename Signature>
>class async_result<executor_binder<T, Executor>, Signature>
>{
>public:
> typedef executor_binder<
> typename async_result<T, Signature>::completion_handler_type, Executor>
> completion_handler_type;
>
> typedef typename async_result<T, Signature>::return_type return_type;
>
> explicit async_result(executor_binder<T, Executor>& b)
> : target_(b.get())
> {
> }
>
> return_type get()
> {
> return target_.get();
> }
>
>private:
> async_result(const async_result&) = delete;
> async_result& operator=(const async_result&) = delete;
>
> async_result<T, Signature> target_;
>};
>
>
>
>template <typename T, typename Executor, typename Signature>
>struct handler_type<executor_binder<T, Executor>, Signature>
>{
> typedef executor_binder<
> typename handler_type<T, Signature>::type, Executor> type;
>};
>
>template <typename T, typename Executor>
>class async_result<executor_binder<T, Executor> >
>{
>public:
> typedef typename async_result<T>::type type;
>
> explicit async_result(executor_binder<T, Executor>& b)
> : target_(b.get())
> {
> }
>
> type get()
> {
> return target_.get();
> }
>
>private:
> async_result<T> target_;
>};
>
>
>
>template <typename T, typename Executor, typename Allocator>
>struct associated_allocator<executor_binder<T, Executor>, Allocator>
>{
> typedef typename associated_allocator<T, Allocator>::type type;
>
> static type get(const executor_binder<T, Executor>& b,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<T, Allocator>::get(b.get(), a);
> }
>};
>
>template <typename T, typename Executor, typename Executor1>
>struct associated_executor<executor_binder<T, Executor>, Executor1>
>{
> typedef Executor type;
>
> static type get(const executor_binder<T, Executor>& b,
> const Executor1& = Executor1()) noexcept
> {
> return b.get_executor();
> }
>};
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 612 "/usr/include/boost/asio/bind_executor.hpp" 2 3 4
># 37 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/buffered_read_stream_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/buffered_read_stream_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>class buffered_read_stream;
>
>}
>}
># 39 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_read_stream.hpp" 1 3 4
># 24 "/usr/include/boost/asio/buffered_read_stream.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Buffer>
>class buffer_resize_guard
>{
>public:
>
> buffer_resize_guard(Buffer& buffer)
> : buffer_(buffer),
> old_size_(buffer.size())
> {
> }
>
>
> ~buffer_resize_guard()
> {
> if (old_size_ != (std::numeric_limits<size_t>::max)())
> {
> buffer_.resize(old_size_);
> }
> }
>
>
> void commit()
> {
> old_size_ = (std::numeric_limits<size_t>::max)();
> }
>
>private:
>
> Buffer& buffer_;
>
>
> size_t old_size_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 67 "/usr/include/boost/asio/detail/buffer_resize_guard.hpp" 2 3 4
># 25 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 23 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class buffered_stream_storage
>{
>public:
>
> typedef unsigned char byte_type;
>
>
> typedef std::size_t size_type;
>
>
> explicit buffered_stream_storage(std::size_t buffer_capacity)
> : begin_offset_(0),
> end_offset_(0),
> buffer_(buffer_capacity)
> {
> }
>
>
> void clear()
> {
> begin_offset_ = 0;
> end_offset_ = 0;
> }
>
>
> mutable_buffer data()
> {
> return boost::asio::buffer(buffer_) + begin_offset_;
> }
>
>
> const_buffer data() const
> {
> return boost::asio::buffer(buffer_) + begin_offset_;
> }
>
>
> bool empty() const
> {
> return begin_offset_ == end_offset_;
> }
>
>
> size_type size() const
> {
> return end_offset_ - begin_offset_;
> }
>
>
> void resize(size_type length)
> {
> (static_cast <bool> (length <= capacity()) ? void (0) : __assert_fail ("length <= capacity()", "/usr/include/boost/asio/detail/buffered_stream_storage.hpp", 82, __extension__ __PRETTY_FUNCTION__));
> if (begin_offset_ + length <= capacity())
> {
> end_offset_ = begin_offset_ + length;
> }
> else
> {
> using namespace std;
> memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
> end_offset_ = length;
> begin_offset_ = 0;
> }
> }
>
>
> size_type capacity() const
> {
> return buffer_.size();
> }
>
>
> void consume(size_type count)
> {
> (static_cast <bool> (begin_offset_ + count <= end_offset_) ? void (0) : __assert_fail ("begin_offset_ + count <= end_offset_", "/usr/include/boost/asio/detail/buffered_stream_storage.hpp", 105, __extension__ __PRETTY_FUNCTION__));
> begin_offset_ += count;
> if (empty())
> clear();
> }
>
>private:
>
> size_type begin_offset_;
>
>
> size_type end_offset_;
>
>
> std::vector<byte_type> buffer_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 127 "/usr/include/boost/asio/detail/buffered_stream_storage.hpp" 2 3 4
># 26 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 48 "/usr/include/boost/asio/buffered_read_stream.hpp" 3 4
>template <typename Stream>
>class buffered_read_stream
> : private noncopyable
>{
>public:
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
> typedef typename lowest_layer_type::executor_type executor_type;
>
>
>
>
>
> static const std::size_t default_buffer_size = 1024;
>
>
>
> template <typename Arg>
> explicit buffered_read_stream(Arg& a)
> : next_layer_(a),
> storage_(default_buffer_size)
> {
> }
>
>
> template <typename Arg>
> buffered_read_stream(Arg& a, std::size_t buffer_size)
> : next_layer_(a),
> storage_(buffer_size)
> {
> }
>
>
> next_layer_type& next_layer()
> {
> return next_layer_;
> }
>
>
> lowest_layer_type& lowest_layer()
> {
> return next_layer_.lowest_layer();
> }
>
>
> const lowest_layer_type& lowest_layer() const
> {
> return next_layer_.lowest_layer();
> }
>
>
> executor_type get_executor() noexcept
> {
> return next_layer_.lowest_layer().get_executor();
> }
>
>
>
>
> boost::asio::io_context& get_io_context()
> {
> return next_layer_.get_io_context();
> }
>
>
>
> boost::asio::io_context& get_io_service()
> {
> return next_layer_.get_io_service();
> }
>
>
>
> void close()
> {
> next_layer_.close();
> }
>
>
> boost::system::error_code close(boost::system::error_code& ec)
> {
> next_layer_.close(ec);
> return ec;
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> return next_layer_.write_some(buffers);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return next_layer_.write_some(buffers, ec);
> }
>
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
> return next_layer_.async_write_some(buffers,
> static_cast<WriteHandler&&>(handler));
> }
>
>
>
> std::size_t fill();
>
>
>
> std::size_t fill(boost::system::error_code& ec);
>
>
> template <typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_fill(ReadHandler&& handler);
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers);
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec);
>
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler);
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers);
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers,
> boost::system::error_code& ec);
>
>
> std::size_t in_avail()
> {
> return storage_.size();
> }
>
>
> std::size_t in_avail(boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> return storage_.size();
> }
>
>private:
>
>
> template <typename MutableBufferSequence>
> std::size_t copy(const MutableBufferSequence& buffers)
> {
> std::size_t bytes_copied = boost::asio::buffer_copy(
> buffers, storage_.data(), storage_.size());
> storage_.consume(bytes_copied);
> return bytes_copied;
> }
>
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek_copy(const MutableBufferSequence& buffers)
> {
> return boost::asio::buffer_copy(buffers, storage_.data(), storage_.size());
> }
>
>
> Stream next_layer_;
>
>
> detail::buffered_stream_storage storage_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 256 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/buffered_read_stream.hpp" 1 3 4
># 25 "/usr/include/boost/asio/impl/buffered_read_stream.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/impl/buffered_read_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>std::size_t buffered_read_stream<Stream>::fill()
>{
> detail::buffer_resize_guard<detail::buffered_stream_storage>
> resize_guard(storage_);
> std::size_t previous_size = storage_.size();
> storage_.resize(storage_.capacity());
> storage_.resize(previous_size + next_layer_.read_some(buffer(
> storage_.data() + previous_size,
> storage_.size() - previous_size)));
> resize_guard.commit();
> return storage_.size() - previous_size;
>}
>
>template <typename Stream>
>std::size_t buffered_read_stream<Stream>::fill(boost::system::error_code& ec)
>{
> detail::buffer_resize_guard<detail::buffered_stream_storage>
> resize_guard(storage_);
> std::size_t previous_size = storage_.size();
> storage_.resize(storage_.capacity());
> storage_.resize(previous_size + next_layer_.read_some(buffer(
> storage_.data() + previous_size,
> storage_.size() - previous_size),
> ec));
> resize_guard.commit();
> return storage_.size() - previous_size;
>}
>
>namespace detail
>{
> template <typename ReadHandler>
> class buffered_fill_handler
> {
> public:
> buffered_fill_handler(detail::buffered_stream_storage& storage,
> std::size_t previous_size, ReadHandler& handler)
> : storage_(storage),
> previous_size_(previous_size),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> buffered_fill_handler(const buffered_fill_handler& other)
> : storage_(other.storage_),
> previous_size_(other.previous_size_),
> handler_(other.handler_)
> {
> }
>
> buffered_fill_handler(buffered_fill_handler&& other)
> : storage_(other.storage_),
> previous_size_(other.previous_size_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> const std::size_t bytes_transferred)
> {
> storage_.resize(previous_size_ + bytes_transferred);
> handler_(ec, bytes_transferred);
> }
>
>
> detail::buffered_stream_storage& storage_;
> std::size_t previous_size_;
> ReadHandler handler_;
> };
>
> template <typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> buffered_fill_handler<ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> buffered_fill_handler<ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename ReadHandler>
> inline bool asio_handler_is_continuation(
> buffered_fill_handler<ReadHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> buffered_fill_handler<ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> buffered_fill_handler<ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::buffered_fill_handler<ReadHandler>, Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(const detail::buffered_fill_handler<ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::buffered_fill_handler<ReadHandler>, Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(const detail::buffered_fill_handler<ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename Stream>
>template <typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>buffered_read_stream<Stream>::async_fill(
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> std::size_t previous_size = storage_.size();
> storage_.resize(storage_.capacity());
> next_layer_.async_read_some(
> buffer(
> storage_.data() + previous_size,
> storage_.size() - previous_size),
> detail::buffered_fill_handler<typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> storage_, previous_size, init.completion_handler));
>
> return init.result.get();
>}
>
>template <typename Stream>
>template <typename MutableBufferSequence>
>std::size_t buffered_read_stream<Stream>::read_some(
> const MutableBufferSequence& buffers)
>{
> using boost::asio::buffer_size;
> if (buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.empty())
> this->fill();
>
> return this->copy(buffers);
>}
>
>template <typename Stream>
>template <typename MutableBufferSequence>
>std::size_t buffered_read_stream<Stream>::read_some(
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
>
> using boost::asio::buffer_size;
> if (buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.empty() && !this->fill(ec))
> return 0;
>
> return this->copy(buffers);
>}
>
>namespace detail
>{
> template <typename MutableBufferSequence, typename ReadHandler>
> class buffered_read_some_handler
> {
> public:
> buffered_read_some_handler(detail::buffered_stream_storage& storage,
> const MutableBufferSequence& buffers, ReadHandler& handler)
> : storage_(storage),
> buffers_(buffers),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> buffered_read_some_handler(const buffered_read_some_handler& other)
> : storage_(other.storage_),
> buffers_(other.buffers_),
> handler_(other.handler_)
> {
> }
>
> buffered_read_some_handler(buffered_read_some_handler&& other)
> : storage_(other.storage_),
> buffers_(other.buffers_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec, std::size_t)
> {
> if (ec || storage_.empty())
> {
> const std::size_t length = 0;
> handler_(ec, length);
> }
> else
> {
> const std::size_t bytes_copied = boost::asio::buffer_copy(
> buffers_, storage_.data(), storage_.size());
> storage_.consume(bytes_copied);
> handler_(ec, bytes_copied);
> }
> }
>
>
> detail::buffered_stream_storage& storage_;
> MutableBufferSequence buffers_;
> ReadHandler handler_;
> };
>
> template <typename MutableBufferSequence, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename MutableBufferSequence, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename MutableBufferSequence, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename MutableBufferSequence,
> typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename MutableBufferSequence,
> typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename MutableBufferSequence,
> typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename MutableBufferSequence,
> typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::buffered_read_some_handler<MutableBufferSequence, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::buffered_read_some_handler<
> MutableBufferSequence, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename Stream>
>template <typename MutableBufferSequence, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>buffered_read_stream<Stream>::async_read_some(
> const MutableBufferSequence& buffers,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> using boost::asio::buffer_size;
> if (buffer_size(buffers) == 0 || !storage_.empty())
> {
> next_layer_.async_read_some(mutable_buffers_1(0, 0),
> detail::buffered_read_some_handler<
> MutableBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> storage_, buffers, init.completion_handler));
> }
> else
> {
> this->async_fill(detail::buffered_read_some_handler<
> MutableBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> storage_, buffers, init.completion_handler));
> }
>
> return init.result.get();
>}
>
>template <typename Stream>
>template <typename MutableBufferSequence>
>std::size_t buffered_read_stream<Stream>::peek(
> const MutableBufferSequence& buffers)
>{
> if (storage_.empty())
> this->fill();
> return this->peek_copy(buffers);
>}
>
>template <typename Stream>
>template <typename MutableBufferSequence>
>std::size_t buffered_read_stream<Stream>::peek(
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> if (storage_.empty() && !this->fill(ec))
> return 0;
> return this->peek_copy(buffers);
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 430 "/usr/include/boost/asio/impl/buffered_read_stream.hpp" 2 3 4
># 258 "/usr/include/boost/asio/buffered_read_stream.hpp" 2 3 4
># 40 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_stream_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/buffered_stream_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>class buffered_stream;
>
>}
>}
># 41 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/buffered_stream.hpp" 1 3 4
># 22 "/usr/include/boost/asio/buffered_stream.hpp" 3 4
># 1 "/usr/include/boost/asio/buffered_write_stream.hpp" 1 3 4
># 20 "/usr/include/boost/asio/buffered_write_stream.hpp" 3 4
># 1 "/usr/include/boost/asio/buffered_write_stream_fwd.hpp" 1 3 4
># 18 "/usr/include/boost/asio/buffered_write_stream_fwd.hpp" 3 4
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>class buffered_write_stream;
>
>}
>}
># 21 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/completion_condition.hpp" 1 3 4
># 21 "/usr/include/boost/asio/completion_condition.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/completion_condition.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>
>enum default_max_transfer_size_t { default_max_transfer_size = 65536 };
>
>
>
>inline std::size_t adapt_completion_condition_result(bool result)
>{
> return result ? 0 : default_max_transfer_size;
>}
>
>
>
>
>inline std::size_t adapt_completion_condition_result(std::size_t result)
>{
> return result;
>}
>
>class transfer_all_t
>{
>public:
> typedef std::size_t result_type;
>
> template <typename Error>
> std::size_t operator()(const Error& err, std::size_t)
> {
> return !!err ? 0 : default_max_transfer_size;
> }
>};
>
>class transfer_at_least_t
>{
>public:
> typedef std::size_t result_type;
>
> explicit transfer_at_least_t(std::size_t minimum)
> : minimum_(minimum)
> {
> }
>
> template <typename Error>
> std::size_t operator()(const Error& err, std::size_t bytes_transferred)
> {
> return (!!err || bytes_transferred >= minimum_)
> ? 0 : default_max_transfer_size;
> }
>
>private:
> std::size_t minimum_;
>};
>
>class transfer_exactly_t
>{
>public:
> typedef std::size_t result_type;
>
> explicit transfer_exactly_t(std::size_t size)
> : size_(size)
> {
> }
>
> template <typename Error>
> std::size_t operator()(const Error& err, std::size_t bytes_transferred)
> {
> return (!!err || bytes_transferred >= size_) ? 0 :
> (size_ - bytes_transferred < default_max_transfer_size
> ? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
> }
>
>private:
> std::size_t size_;
>};
>
>}
># 139 "/usr/include/boost/asio/completion_condition.hpp" 3 4
>inline detail::transfer_all_t transfer_all()
>{
> return detail::transfer_all_t();
>}
># 173 "/usr/include/boost/asio/completion_condition.hpp" 3 4
>inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
>{
> return detail::transfer_at_least_t(minimum);
>}
># 207 "/usr/include/boost/asio/completion_condition.hpp" 3 4
>inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
>{
> return detail::transfer_exactly_t(size);
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 219 "/usr/include/boost/asio/completion_condition.hpp" 2 3 4
># 23 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/write.hpp" 1 3 4
># 28 "/usr/include/boost/asio/write.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/write.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 76 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type* = 0);
># 118 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type* = 0);
># 171 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type* = 0);
># 218 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type* = 0);
># 253 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename DynamicBuffer>
>std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 287 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename DynamicBuffer>
>std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 331 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 377 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 415 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
># 444 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 483 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition);
># 524 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 593 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> WriteHandler&& handler,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type* = 0);
># 670 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type* = 0);
># 724 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream,
> typename DynamicBuffer, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s,
> DynamicBuffer&& buffers,
> WriteHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 792 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 848 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
> WriteHandler&& handler);
># 909 "/usr/include/boost/asio/write.hpp" 3 4
>template <typename AsyncWriteStream, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> WriteHandler&& handler);
>
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 926 "/usr/include/boost/asio/write.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/write.hpp" 1 3 4
># 23 "/usr/include/boost/asio/impl/write.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename CompletionCondition>
>class base_from_completion_cond
>{
>protected:
> explicit base_from_completion_cond(CompletionCondition completion_condition)
> : completion_condition_(completion_condition)
> {
> }
>
> std::size_t check_for_completion(
> const boost::system::error_code& ec,
> std::size_t total_transferred)
> {
> return detail::adapt_completion_condition_result(
> completion_condition_(ec, total_transferred));
> }
>
>private:
> CompletionCondition completion_condition_;
>};
>
>template <>
>class base_from_completion_cond<transfer_all_t>
>{
>protected:
> explicit base_from_completion_cond(transfer_all_t)
> {
> }
>
> static std::size_t check_for_completion(
> const boost::system::error_code& ec,
> std::size_t total_transferred)
> {
> return transfer_all_t()(ec, total_transferred);
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 69 "/usr/include/boost/asio/detail/base_from_completion_cond.hpp" 2 3 4
># 24 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>template <typename Buffers>
>struct prepared_buffers_max
>{
> enum { value = buffer_sequence_adapter_base::max_buffers };
>};
>
>template <typename Elem, std::size_t N>
>struct prepared_buffers_max<boost::array<Elem, N> >
>{
> enum { value = N };
>};
>
>
>
>template <typename Elem, std::size_t N>
>struct prepared_buffers_max<std::array<Elem, N> >
>{
> enum { value = N };
>};
>
>
>
>
>template <typename Buffer, std::size_t MaxBuffers>
>struct prepared_buffers
>{
> typedef Buffer value_type;
> typedef const Buffer* const_iterator;
>
> enum { max_buffers = MaxBuffers < 16 ? MaxBuffers : 16 };
>
> prepared_buffers() : count(0) {}
> const_iterator begin() const { return elems; }
> const_iterator end() const { return elems + count; }
>
> Buffer elems[max_buffers];
> std::size_t count;
>};
>
>
>template <typename Buffer, typename Buffers, typename Buffer_Iterator>
>class consuming_buffers
>{
>public:
> typedef prepared_buffers<Buffer, prepared_buffers_max<Buffers>::value>
> prepared_buffers_type;
>
>
> explicit consuming_buffers(const Buffers& buffers)
> : buffers_(buffers),
> total_consumed_(0),
> next_elem_(0),
> next_elem_offset_(0)
> {
> using boost::asio::buffer_size;
> total_size_ = buffer_size(buffers);
> }
>
>
> bool empty() const
> {
> return total_consumed_ >= total_size_;
> }
>
>
> prepared_buffers_type prepare(std::size_t max_size)
> {
> prepared_buffers_type result;
>
> Buffer_Iterator next = boost::asio::buffer_sequence_begin(buffers_);
> Buffer_Iterator end = boost::asio::buffer_sequence_end(buffers_);
>
> std::advance(next, next_elem_);
> std::size_t elem_offset = next_elem_offset_;
> while (next != end && max_size > 0 && result.count < result.max_buffers)
> {
> Buffer next_buf = Buffer(*next) + elem_offset;
> result.elems[result.count] = boost::asio::buffer(next_buf, max_size);
> max_size -= result.elems[result.count].size();
> elem_offset = 0;
> if (result.elems[result.count].size() > 0)
> ++result.count;
> ++next;
> }
>
> return result;
> }
>
>
> void consume(std::size_t size)
> {
> total_consumed_ += size;
>
> Buffer_Iterator next = boost::asio::buffer_sequence_begin(buffers_);
> Buffer_Iterator end = boost::asio::buffer_sequence_end(buffers_);
>
> std::advance(next, next_elem_);
> while (next != end && size > 0)
> {
> Buffer next_buf = Buffer(*next) + next_elem_offset_;
> if (size < next_buf.size())
> {
> next_elem_offset_ += size;
> size = 0;
> }
> else
> {
> size -= next_buf.size();
> next_elem_offset_ = 0;
> ++next_elem_;
> ++next;
> }
> }
> }
>
>
> std::size_t total_consumed() const
> {
> return total_consumed_;
> }
>
>private:
> Buffers buffers_;
> std::size_t total_size_;
> std::size_t total_consumed_;
> std::size_t next_elem_;
> std::size_t next_elem_offset_;
>};
>
>
>template <typename Buffer>
>class consuming_single_buffer
>{
>public:
>
> template <typename Buffer1>
> explicit consuming_single_buffer(const Buffer1& buffer)
> : buffer_(buffer),
> total_consumed_(0)
> {
> }
>
>
> bool empty() const
> {
> return total_consumed_ >= buffer_.size();
> }
>
>
> Buffer prepare(std::size_t max_size)
> {
> return boost::asio::buffer(buffer_ + total_consumed_, max_size);
> }
>
>
> void consume(std::size_t size)
> {
> total_consumed_ += size;
> }
>
>
> std::size_t total_consumed() const
> {
> return total_consumed_;
> }
>
>private:
> Buffer buffer_;
> std::size_t total_consumed_;
>};
>
>template <>
>class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer*>
> : public consuming_single_buffer<mutable_buffers_1>
>{
>public:
> explicit consuming_buffers(const mutable_buffer& buffer)
> : consuming_single_buffer<mutable_buffers_1>(buffer)
> {
> }
>};
>
>template <>
>class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer*>
> : public consuming_single_buffer<const_buffers_1>
>{
>public:
> explicit consuming_buffers(const mutable_buffer& buffer)
> : consuming_single_buffer<const_buffers_1>(buffer)
> {
> }
>};
>
>template <>
>class consuming_buffers<const_buffer, const_buffer, const const_buffer*>
> : public consuming_single_buffer<const_buffers_1>
>{
>public:
> explicit consuming_buffers(const const_buffer& buffer)
> : consuming_single_buffer<const_buffers_1>(buffer)
> {
> }
>};
>
>
>
>template <>
>class consuming_buffers<mutable_buffer,
> mutable_buffers_1, const mutable_buffer*>
> : public consuming_single_buffer<mutable_buffers_1>
>{
>public:
> explicit consuming_buffers(const mutable_buffers_1& buffer)
> : consuming_single_buffer<mutable_buffers_1>(buffer)
> {
> }
>};
>
>template <>
>class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer*>
> : public consuming_single_buffer<const_buffers_1>
>{
>public:
> explicit consuming_buffers(const mutable_buffers_1& buffer)
> : consuming_single_buffer<const_buffers_1>(buffer)
> {
> }
>};
>
>template <>
>class consuming_buffers<const_buffer, const_buffers_1, const const_buffer*>
> : public consuming_single_buffer<const_buffers_1>
>{
>public:
> explicit consuming_buffers(const const_buffers_1& buffer)
> : consuming_single_buffer<const_buffers_1>(buffer)
> {
> }
>};
>
>
>
>template <typename Buffer, typename Elem>
>class consuming_buffers<Buffer, boost::array<Elem, 2>,
> typename boost::array<Elem, 2>::const_iterator>
>{
>public:
>
> explicit consuming_buffers(const boost::array<Elem, 2>& buffers)
> : buffers_(buffers),
> total_consumed_(0)
> {
> }
>
>
> bool empty() const
> {
> return total_consumed_ >=
> Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
> }
>
>
> boost::array<Buffer, 2> prepare(std::size_t max_size)
> {
> boost::array<Buffer, 2> result = {{
> Buffer(buffers_[0]), Buffer(buffers_[1]) }};
> std::size_t buffer0_size = result[0].size();
> result[0] = boost::asio::buffer(result[0] + total_consumed_, max_size);
> result[1] = boost::asio::buffer(
> result[1] + (total_consumed_ < buffer0_size
> ? 0 : total_consumed_ - buffer0_size),
> max_size - result[0].size());
> return result;
> }
>
>
> void consume(std::size_t size)
> {
> total_consumed_ += size;
> }
>
>
> std::size_t total_consumed() const
> {
> return total_consumed_;
> }
>
>private:
> boost::array<Elem, 2> buffers_;
> std::size_t total_consumed_;
>};
>
>
>
>template <typename Buffer, typename Elem>
>class consuming_buffers<Buffer, std::array<Elem, 2>,
> typename std::array<Elem, 2>::const_iterator>
>{
>public:
>
> explicit consuming_buffers(const std::array<Elem, 2>& buffers)
> : buffers_(buffers),
> total_consumed_(0)
> {
> }
>
>
> bool empty() const
> {
> return total_consumed_ >=
> Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
> }
>
>
> std::array<Buffer, 2> prepare(std::size_t max_size)
> {
> std::array<Buffer, 2> result = {{
> Buffer(buffers_[0]), Buffer(buffers_[1]) }};
> std::size_t buffer0_size = result[0].size();
> result[0] = boost::asio::buffer(result[0] + total_consumed_, max_size);
> result[1] = boost::asio::buffer(
> result[1] + (total_consumed_ < buffer0_size
> ? 0 : total_consumed_ - buffer0_size),
> max_size - result[0].size());
> return result;
> }
>
>
> void consume(std::size_t size)
> {
> total_consumed_ += size;
> }
>
>
> std::size_t total_consumed() const
> {
> return total_consumed_;
> }
>
>private:
> std::array<Elem, 2> buffers_;
> std::size_t total_consumed_;
>};
>
>
>
>
>
>template <typename Buffer>
>class consuming_buffers<Buffer, null_buffers, const mutable_buffer*>
> : public boost::asio::null_buffers
>{
>public:
> consuming_buffers(const null_buffers&)
> {
>
> }
>
> bool empty()
> {
> return false;
> }
>
> null_buffers prepare(std::size_t)
> {
> return null_buffers();
> }
>
> void consume(std::size_t)
> {
>
> }
>
> std::size_t total_consume() const
> {
> return 0;
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 415 "/usr/include/boost/asio/detail/consuming_buffers.hpp" 2 3 4
># 26 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/dependent_type.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/dependent_type.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/detail/dependent_type.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename DependsOn, typename T>
>struct dependent_type
>{
> typedef T type;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 37 "/usr/include/boost/asio/detail/dependent_type.hpp" 2 3 4
># 27 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 34 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> template <typename SyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition>
> std::size_t write_buffer_sequence(SyncWriteStream& s,
> const ConstBufferSequence& buffers, const ConstBufferIterator&,
> CompletionCondition completion_condition, boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<const_buffer,
> ConstBufferSequence, ConstBufferIterator> tmp(buffers);
> while (!tmp.empty())
> {
> if (std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, tmp.total_consumed())))
> tmp.consume(s.write_some(tmp.prepare(max_size), ec));
> else
> break;
> }
> return tmp.total_consumed();;
> }
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type*)
>{
> return detail::write_buffer_sequence(s, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type*)
>{
> return write(s, buffers, transfer_all(), ec);
>}
>
>template <typename SyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition>
>std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> typename decay<DynamicBuffer>::type b(
> static_cast<DynamicBuffer&&>(buffers));
>
> std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
> b.consume(bytes_transferred);
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename DynamicBuffer>
>inline std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s,
> static_cast<DynamicBuffer&&>(buffers),
> transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>template <typename SyncWriteStream, typename DynamicBuffer>
>inline std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> return write(s, static_cast<DynamicBuffer&&>(buffers),
> transfer_all(), ec);
>}
>
>template <typename SyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write(s,
> static_cast<DynamicBuffer&&>(buffers),
> completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write");
> return bytes_transferred;
>}
>
>
>
>
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> return write(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
>}
>
>template <typename SyncWriteStream, typename Allocator>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b)
>{
> return write(s, basic_streambuf_ref<Allocator>(b));
>}
>
>template <typename SyncWriteStream, typename Allocator>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return write(s, basic_streambuf_ref<Allocator>(b), ec);
>}
>
>template <typename SyncWriteStream, typename Allocator,
> typename CompletionCondition>
>inline std::size_t write(SyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> return write(s, basic_streambuf_ref<Allocator>(b), completion_condition);
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler>
> class write_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_op(const write_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> write_op(write_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> do
> {
> stream_.async_write_some(buffers_.prepare(max_size),
> static_cast<write_op&&>(*this));
> return; default:
> buffers_.consume(bytes_transferred);
> if ((!ec && bytes_transferred == 0) || buffers_.empty())
> break;
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> } while (max_size > 0);
>
> handler_(ec, buffers_.total_consumed());
> }
> }
>
>
> AsyncWriteStream& stream_;
> boost::asio::detail::consuming_buffers<const_buffer,
> ConstBufferSequence, ConstBufferIterator> buffers_;
> int start_;
> WriteHandler handler_;
> };
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncWriteStream,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncWriteStream,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_op<AsyncWriteStream, ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler>
> inline void start_write_buffer_sequence_op(AsyncWriteStream& stream,
> const ConstBufferSequence& buffers, const ConstBufferIterator&,
> CompletionCondition completion_condition, WriteHandler& handler)
> {
> detail::write_op<AsyncWriteStream, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>(
> stream, buffers, completion_condition, handler)(
> boost::system::error_code(), 0, 1);
> }
>
>}
>
>
>
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler, typename Allocator>
>struct associated_allocator<
> detail::write_op<AsyncWriteStream, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>,
> Allocator>
>{
> typedef typename associated_allocator<WriteHandler, Allocator>::type type;
>
> static type get(
> const detail::write_op<AsyncWriteStream, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition,
> typename WriteHandler, typename Executor>
>struct associated_executor<
> detail::write_op<AsyncWriteStream, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>,
> Executor>
>{
> typedef typename associated_executor<WriteHandler, Executor>::type type;
>
> static type get(
> const detail::write_op<AsyncWriteStream, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_write_buffer_sequence_op(s, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition,
> init.completion_handler);
>
> return init.result.get();
>}
>
>template <typename AsyncWriteStream, typename ConstBufferSequence,
> typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
> WriteHandler&& handler,
> typename enable_if<
> is_const_buffer_sequence<ConstBufferSequence>::value
> >::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_write_buffer_sequence_op(s, buffers,
> boost::asio::buffer_sequence_begin(buffers), transfer_all(),
> init.completion_handler);
>
> return init.result.get();
>}
>
>namespace detail
>{
> template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler>
> class write_dynbuf_op
> {
> public:
> template <typename BufferSequence>
> write_dynbuf_op(AsyncWriteStream& stream,
> BufferSequence&& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : stream_(stream),
> buffers_(static_cast<BufferSequence&&>(buffers)),
> completion_condition_(
> static_cast<CompletionCondition&&>(completion_condition)),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_dynbuf_op(const write_dynbuf_op& other)
> : stream_(other.stream_),
> buffers_(other.buffers_),
> completion_condition_(other.completion_condition_),
> handler_(other.handler_)
> {
> }
>
> write_dynbuf_op(write_dynbuf_op&& other)
> : stream_(other.stream_),
> buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
> completion_condition_(
> static_cast<CompletionCondition&&>(
> other.completion_condition_)),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> switch (start)
> {
> case 1:
> async_write(stream_, buffers_.data(), completion_condition_,
> static_cast<write_dynbuf_op&&>(*this));
> return; default:
> buffers_.consume(bytes_transferred);
> handler_(ec, static_cast<const std::size_t&>(bytes_transferred));
> }
> }
>
>
> AsyncWriteStream& stream_;
> DynamicBuffer buffers_;
> CompletionCondition completion_condition_;
> WriteHandler handler_;
> };
>
> template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
> CompletionCondition, WriteHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncWriteStream,
> typename DynamicBuffer, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncWriteStream,
> typename DynamicBuffer, typename CompletionCondition,
> typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_dynbuf_op<AsyncWriteStream, DynamicBuffer,
> CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler, typename Allocator>
>struct associated_allocator<
> detail::write_dynbuf_op<AsyncWriteStream,
> DynamicBuffer, CompletionCondition, WriteHandler>,
> Allocator>
>{
> typedef typename associated_allocator<WriteHandler, Allocator>::type type;
>
> static type get(
> const detail::write_dynbuf_op<AsyncWriteStream,
> DynamicBuffer, CompletionCondition, WriteHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler, typename Executor>
>struct associated_executor<
> detail::write_dynbuf_op<AsyncWriteStream,
> DynamicBuffer, CompletionCondition, WriteHandler>,
> Executor>
>{
> typedef typename associated_executor<WriteHandler, Executor>::type type;
>
> static type get(
> const detail::write_dynbuf_op<AsyncWriteStream,
> DynamicBuffer, CompletionCondition, WriteHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncWriteStream,
> typename DynamicBuffer, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s,
> DynamicBuffer&& buffers,
> WriteHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> return async_write(s,
> static_cast<DynamicBuffer&&>(buffers),
> transfer_all(), static_cast<WriteHandler&&>(handler));
>}
>
>template <typename AsyncWriteStream, typename DynamicBuffer,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::write_dynbuf_op<AsyncWriteStream,
> typename decay<DynamicBuffer>::type,
> CompletionCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> s, static_cast<DynamicBuffer&&>(buffers),
> completion_condition, init.completion_handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>
>template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> WriteHandler&& handler)
>{
> return async_write(s, basic_streambuf_ref<Allocator>(b),
> static_cast<WriteHandler&&>(handler));
>}
>
>template <typename AsyncWriteStream, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write(AsyncWriteStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
> return async_write(s, basic_streambuf_ref<Allocator>(b),
> completion_condition, static_cast<WriteHandler&&>(handler));
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 675 "/usr/include/boost/asio/impl/write.hpp" 2 3 4
># 928 "/usr/include/boost/asio/write.hpp" 2 3 4
># 30 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 48 "/usr/include/boost/asio/buffered_write_stream.hpp" 3 4
>template <typename Stream>
>class buffered_write_stream
> : private noncopyable
>{
>public:
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
> typedef typename lowest_layer_type::executor_type executor_type;
>
>
>
>
>
> static const std::size_t default_buffer_size = 1024;
>
>
>
> template <typename Arg>
> explicit buffered_write_stream(Arg& a)
> : next_layer_(a),
> storage_(default_buffer_size)
> {
> }
>
>
> template <typename Arg>
> buffered_write_stream(Arg& a, std::size_t buffer_size)
> : next_layer_(a),
> storage_(buffer_size)
> {
> }
>
>
> next_layer_type& next_layer()
> {
> return next_layer_;
> }
>
>
> lowest_layer_type& lowest_layer()
> {
> return next_layer_.lowest_layer();
> }
>
>
> const lowest_layer_type& lowest_layer() const
> {
> return next_layer_.lowest_layer();
> }
>
>
> executor_type get_executor() noexcept
> {
> return next_layer_.lowest_layer().get_executor();
> }
>
>
>
>
> boost::asio::io_context& get_io_context()
> {
> return next_layer_.get_io_context();
> }
>
>
>
> boost::asio::io_context& get_io_service()
> {
> return next_layer_.get_io_service();
> }
>
>
>
> void close()
> {
> next_layer_.close();
> }
>
>
> boost::system::error_code close(boost::system::error_code& ec)
> {
> next_layer_.close(ec);
> return ec;
> }
>
>
>
>
> std::size_t flush();
>
>
>
>
> std::size_t flush(boost::system::error_code& ec);
>
>
> template <typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_flush(WriteHandler&& handler);
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers);
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec);
>
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler);
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> return next_layer_.read_some(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return next_layer_.read_some(buffers, ec);
> }
>
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
> return next_layer_.async_read_some(buffers,
> static_cast<ReadHandler&&>(handler));
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers)
> {
> return next_layer_.peek(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return next_layer_.peek(buffers, ec);
> }
>
>
> std::size_t in_avail()
> {
> return next_layer_.in_avail();
> }
>
>
> std::size_t in_avail(boost::system::error_code& ec)
> {
> return next_layer_.in_avail(ec);
> }
>
>private:
>
>
> template <typename ConstBufferSequence>
> std::size_t copy(const ConstBufferSequence& buffers);
>
>
> Stream next_layer_;
>
>
> detail::buffered_stream_storage storage_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 248 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/buffered_write_stream.hpp" 1 3 4
># 25 "/usr/include/boost/asio/impl/buffered_write_stream.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/impl/buffered_write_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename Stream>
>std::size_t buffered_write_stream<Stream>::flush()
>{
> std::size_t bytes_written = write(next_layer_,
> buffer(storage_.data(), storage_.size()));
> storage_.consume(bytes_written);
> return bytes_written;
>}
>
>template <typename Stream>
>std::size_t buffered_write_stream<Stream>::flush(boost::system::error_code& ec)
>{
> std::size_t bytes_written = write(next_layer_,
> buffer(storage_.data(), storage_.size()),
> transfer_all(), ec);
> storage_.consume(bytes_written);
> return bytes_written;
>}
>
>namespace detail
>{
> template <typename WriteHandler>
> class buffered_flush_handler
> {
> public:
> buffered_flush_handler(detail::buffered_stream_storage& storage,
> WriteHandler& handler)
> : storage_(storage),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> buffered_flush_handler(const buffered_flush_handler& other)
> : storage_(other.storage_),
> handler_(other.handler_)
> {
> }
>
> buffered_flush_handler(buffered_flush_handler&& other)
> : storage_(other.storage_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> const std::size_t bytes_written)
> {
> storage_.consume(bytes_written);
> handler_(ec, bytes_written);
> }
>
>
> detail::buffered_stream_storage& storage_;
> WriteHandler handler_;
> };
>
> template <typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> buffered_flush_handler<WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> buffered_flush_handler<WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename WriteHandler>
> inline bool asio_handler_is_continuation(
> buffered_flush_handler<WriteHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> buffered_flush_handler<WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> buffered_flush_handler<WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename WriteHandler, typename Allocator>
>struct associated_allocator<
> detail::buffered_flush_handler<WriteHandler>, Allocator>
>{
> typedef typename associated_allocator<WriteHandler, Allocator>::type type;
>
> static type get(const detail::buffered_flush_handler<WriteHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename WriteHandler, typename Executor>
>struct associated_executor<
> detail::buffered_flush_handler<WriteHandler>, Executor>
>{
> typedef typename associated_executor<WriteHandler, Executor>::type type;
>
> static type get(const detail::buffered_flush_handler<WriteHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename Stream>
>template <typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>buffered_write_stream<Stream>::async_flush(
> WriteHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> async_write(next_layer_, buffer(storage_.data(), storage_.size()),
> detail::buffered_flush_handler<typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> storage_, init.completion_handler));
>
> return init.result.get();
>}
>
>template <typename Stream>
>template <typename ConstBufferSequence>
>std::size_t buffered_write_stream<Stream>::write_some(
> const ConstBufferSequence& buffers)
>{
> using boost::asio::buffer_size;
> if (buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.size() == storage_.capacity())
> this->flush();
>
> return this->copy(buffers);
>}
>
>template <typename Stream>
>template <typename ConstBufferSequence>
>std::size_t buffered_write_stream<Stream>::write_some(
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
>
> using boost::asio::buffer_size;
> if (buffer_size(buffers) == 0)
> return 0;
>
> if (storage_.size() == storage_.capacity() && !flush(ec))
> return 0;
>
> return this->copy(buffers);
>}
>
>namespace detail
>{
> template <typename ConstBufferSequence, typename WriteHandler>
> class buffered_write_some_handler
> {
> public:
> buffered_write_some_handler(detail::buffered_stream_storage& storage,
> const ConstBufferSequence& buffers, WriteHandler& handler)
> : storage_(storage),
> buffers_(buffers),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> buffered_write_some_handler(const buffered_write_some_handler& other)
> : storage_(other.storage_),
> buffers_(other.buffers_),
> handler_(other.handler_)
> {
> }
>
> buffered_write_some_handler(buffered_write_some_handler&& other)
> : storage_(other.storage_),
> buffers_(other.buffers_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec, std::size_t)
> {
> if (ec)
> {
> const std::size_t length = 0;
> handler_(ec, length);
> }
> else
> {
> using boost::asio::buffer_size;
> std::size_t orig_size = storage_.size();
> std::size_t space_avail = storage_.capacity() - orig_size;
> std::size_t bytes_avail = buffer_size(buffers_);
> std::size_t length = bytes_avail < space_avail
> ? bytes_avail : space_avail;
> storage_.resize(orig_size + length);
> const std::size_t bytes_copied = boost::asio::buffer_copy(
> storage_.data() + orig_size, buffers_, length);
> handler_(ec, bytes_copied);
> }
> }
>
>
> detail::buffered_stream_storage& storage_;
> ConstBufferSequence buffers_;
> WriteHandler handler_;
> };
>
> template <typename ConstBufferSequence, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename ConstBufferSequence, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename ConstBufferSequence, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename ConstBufferSequence,
> typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename ConstBufferSequence,
> typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename ConstBufferSequence,
> typename WriteHandler, typename Allocator>
>struct associated_allocator<
> detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
> Allocator>
>{
> typedef typename associated_allocator<WriteHandler, Allocator>::type type;
>
> static type get(
> const detail::buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename ConstBufferSequence,
> typename WriteHandler, typename Executor>
>struct associated_executor<
> detail::buffered_write_some_handler<ConstBufferSequence, WriteHandler>,
> Executor>
>{
> typedef typename associated_executor<WriteHandler, Executor>::type type;
>
> static type get(
> const detail::buffered_write_some_handler<
> ConstBufferSequence, WriteHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename Stream>
>template <typename ConstBufferSequence, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>buffered_write_stream<Stream>::async_write_some(
> const ConstBufferSequence& buffers,
> WriteHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> using boost::asio::buffer_size;
> if (buffer_size(buffers) == 0
> || storage_.size() < storage_.capacity())
> {
> next_layer_.async_write_some(const_buffers_1(0, 0),
> detail::buffered_write_some_handler<
> ConstBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> storage_, buffers, init.completion_handler));
> }
> else
> {
> this->async_flush(detail::buffered_write_some_handler<
> ConstBufferSequence, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> storage_, buffers, init.completion_handler));
> }
>
> return init.result.get();
>}
>
>template <typename Stream>
>template <typename ConstBufferSequence>
>std::size_t buffered_write_stream<Stream>::copy(
> const ConstBufferSequence& buffers)
>{
> using boost::asio::buffer_size;
> std::size_t orig_size = storage_.size();
> std::size_t space_avail = storage_.capacity() - orig_size;
> std::size_t bytes_avail = buffer_size(buffers);
> std::size_t length = bytes_avail < space_avail ? bytes_avail : space_avail;
> storage_.resize(orig_size + length);
> return boost::asio::buffer_copy(
> storage_.data() + orig_size, buffers, length);
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 412 "/usr/include/boost/asio/impl/buffered_write_stream.hpp" 2 3 4
># 250 "/usr/include/boost/asio/buffered_write_stream.hpp" 2 3 4
># 23 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 45 "/usr/include/boost/asio/buffered_stream.hpp" 3 4
>template <typename Stream>
>class buffered_stream
> : private noncopyable
>{
>public:
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
> typedef typename lowest_layer_type::executor_type executor_type;
>
>
> template <typename Arg>
> explicit buffered_stream(Arg& a)
> : inner_stream_impl_(a),
> stream_impl_(inner_stream_impl_)
> {
> }
>
>
> template <typename Arg>
> explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
> std::size_t write_buffer_size)
> : inner_stream_impl_(a, write_buffer_size),
> stream_impl_(inner_stream_impl_, read_buffer_size)
> {
> }
>
>
> next_layer_type& next_layer()
> {
> return stream_impl_.next_layer().next_layer();
> }
>
>
> lowest_layer_type& lowest_layer()
> {
> return stream_impl_.lowest_layer();
> }
>
>
> const lowest_layer_type& lowest_layer() const
> {
> return stream_impl_.lowest_layer();
> }
>
>
> executor_type get_executor() noexcept
> {
> return stream_impl_.lowest_layer().get_executor();
> }
>
>
>
>
> boost::asio::io_context& get_io_context()
> {
> return stream_impl_.get_io_context();
> }
>
>
>
> boost::asio::io_context& get_io_service()
> {
> return stream_impl_.get_io_service();
> }
>
>
>
> void close()
> {
> stream_impl_.close();
> }
>
>
> boost::system::error_code close(boost::system::error_code& ec)
> {
> stream_impl_.close(ec);
> return ec;
> }
>
>
>
>
> std::size_t flush()
> {
> return stream_impl_.next_layer().flush();
> }
>
>
>
>
> std::size_t flush(boost::system::error_code& ec)
> {
> return stream_impl_.next_layer().flush(ec);
> }
>
>
> template <typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_flush(WriteHandler&& handler)
> {
> return stream_impl_.next_layer().async_flush(
> static_cast<WriteHandler&&>(handler));
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> return stream_impl_.write_some(buffers);
> }
>
>
>
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return stream_impl_.write_some(buffers, ec);
> }
>
>
>
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
> return stream_impl_.async_write_some(buffers,
> static_cast<WriteHandler&&>(handler));
> }
>
>
>
> std::size_t fill()
> {
> return stream_impl_.fill();
> }
>
>
>
> std::size_t fill(boost::system::error_code& ec)
> {
> return stream_impl_.fill(ec);
> }
>
>
> template <typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_fill(ReadHandler&& handler)
> {
> return stream_impl_.async_fill(static_cast<ReadHandler&&>(handler));
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> return stream_impl_.read_some(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return stream_impl_.read_some(buffers, ec);
> }
>
>
>
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
> return stream_impl_.async_read_some(buffers,
> static_cast<ReadHandler&&>(handler));
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers)
> {
> return stream_impl_.peek(buffers);
> }
>
>
>
> template <typename MutableBufferSequence>
> std::size_t peek(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return stream_impl_.peek(buffers, ec);
> }
>
>
> std::size_t in_avail()
> {
> return stream_impl_.in_avail();
> }
>
>
> std::size_t in_avail(boost::system::error_code& ec)
> {
> return stream_impl_.in_avail(ec);
> }
>
>private:
>
> typedef buffered_write_stream<Stream> write_stream_type;
> write_stream_type inner_stream_impl_;
>
>
> typedef buffered_read_stream<write_stream_type&> read_stream_type;
> read_stream_type stream_impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 279 "/usr/include/boost/asio/buffered_stream.hpp" 2 3 4
># 42 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/buffers_iterator.hpp" 1 3 4
># 25 "/usr/include/boost/asio/buffers_iterator.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/buffers_iterator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> template <bool IsMutable>
> struct buffers_iterator_types_helper;
>
> template <>
> struct buffers_iterator_types_helper<false>
> {
> typedef const_buffer buffer_type;
> template <typename ByteType>
> struct byte_type
> {
> typedef typename add_const<ByteType>::type type;
> };
> };
>
> template <>
> struct buffers_iterator_types_helper<true>
> {
> typedef mutable_buffer buffer_type;
> template <typename ByteType>
> struct byte_type
> {
> typedef ByteType type;
> };
> };
>
> template <typename BufferSequence, typename ByteType>
> struct buffers_iterator_types
> {
> enum
> {
> is_mutable = is_convertible<
> typename BufferSequence::value_type,
> mutable_buffer>::value
> };
> typedef buffers_iterator_types_helper<is_mutable> helper;
> typedef typename helper::buffer_type buffer_type;
> typedef typename helper::template byte_type<ByteType>::type byte_type;
> typedef typename BufferSequence::const_iterator const_iterator;
> };
>
> template <typename ByteType>
> struct buffers_iterator_types<mutable_buffer, ByteType>
> {
> typedef mutable_buffer buffer_type;
> typedef ByteType byte_type;
> typedef const mutable_buffer* const_iterator;
> };
>
> template <typename ByteType>
> struct buffers_iterator_types<const_buffer, ByteType>
> {
> typedef const_buffer buffer_type;
> typedef typename add_const<ByteType>::type byte_type;
> typedef const const_buffer* const_iterator;
> };
>
>
>
> template <typename ByteType>
> struct buffers_iterator_types<mutable_buffers_1, ByteType>
> {
> typedef mutable_buffer buffer_type;
> typedef ByteType byte_type;
> typedef const mutable_buffer* const_iterator;
> };
>
> template <typename ByteType>
> struct buffers_iterator_types<const_buffers_1, ByteType>
> {
> typedef const_buffer buffer_type;
> typedef typename add_const<ByteType>::type byte_type;
> typedef const const_buffer* const_iterator;
> };
>
>
>}
>
>
>template <typename BufferSequence, typename ByteType = char>
>class buffers_iterator
>{
>private:
> typedef typename detail::buffers_iterator_types<
> BufferSequence, ByteType>::buffer_type buffer_type;
>
> typedef typename detail::buffers_iterator_types<BufferSequence,
> ByteType>::const_iterator buffer_sequence_iterator_type;
>
>public:
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef ByteType value_type;
># 136 "/usr/include/boost/asio/buffers_iterator.hpp" 3 4
> typedef typename detail::buffers_iterator_types<
> BufferSequence, ByteType>::byte_type* pointer;
># 149 "/usr/include/boost/asio/buffers_iterator.hpp" 3 4
> typedef typename detail::buffers_iterator_types<
> BufferSequence, ByteType>::byte_type& reference;
>
>
>
> typedef std::random_access_iterator_tag iterator_category;
>
>
> buffers_iterator()
> : current_buffer_(),
> current_buffer_position_(0),
> begin_(),
> current_(),
> end_(),
> position_(0)
> {
> }
>
>
> static buffers_iterator begin(const BufferSequence& buffers)
>
>
>
> {
> buffers_iterator new_iter;
> new_iter.begin_ = boost::asio::buffer_sequence_begin(buffers);
> new_iter.current_ = boost::asio::buffer_sequence_begin(buffers);
> new_iter.end_ = boost::asio::buffer_sequence_end(buffers);
> while (new_iter.current_ != new_iter.end_)
> {
> new_iter.current_buffer_ = *new_iter.current_;
> if (new_iter.current_buffer_.size() > 0)
> break;
> ++new_iter.current_;
> }
> return new_iter;
> }
>
>
> static buffers_iterator end(const BufferSequence& buffers)
>
>
>
> {
> buffers_iterator new_iter;
> new_iter.begin_ = boost::asio::buffer_sequence_begin(buffers);
> new_iter.current_ = boost::asio::buffer_sequence_begin(buffers);
> new_iter.end_ = boost::asio::buffer_sequence_end(buffers);
> while (new_iter.current_ != new_iter.end_)
> {
> buffer_type buffer = *new_iter.current_;
> new_iter.position_ += buffer.size();
> ++new_iter.current_;
> }
> return new_iter;
> }
>
>
> reference operator*() const
> {
> return dereference();
> }
>
>
> pointer operator->() const
> {
> return &dereference();
> }
>
>
> reference operator[](std::ptrdiff_t difference) const
> {
> buffers_iterator tmp(*this);
> tmp.advance(difference);
> return *tmp;
> }
>
>
> buffers_iterator& operator++()
> {
> increment();
> return *this;
> }
>
>
> buffers_iterator operator++(int)
> {
> buffers_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> buffers_iterator& operator--()
> {
> decrement();
> return *this;
> }
>
>
> buffers_iterator operator--(int)
> {
> buffers_iterator tmp(*this);
> --*this;
> return tmp;
> }
>
>
> buffers_iterator& operator+=(std::ptrdiff_t difference)
> {
> advance(difference);
> return *this;
> }
>
>
> buffers_iterator& operator-=(std::ptrdiff_t difference)
> {
> advance(-difference);
> return *this;
> }
>
>
> friend buffers_iterator operator+(const buffers_iterator& iter,
> std::ptrdiff_t difference)
> {
> buffers_iterator tmp(iter);
> tmp.advance(difference);
> return tmp;
> }
>
>
> friend buffers_iterator operator+(std::ptrdiff_t difference,
> const buffers_iterator& iter)
> {
> buffers_iterator tmp(iter);
> tmp.advance(difference);
> return tmp;
> }
>
>
> friend buffers_iterator operator-(const buffers_iterator& iter,
> std::ptrdiff_t difference)
> {
> buffers_iterator tmp(iter);
> tmp.advance(-difference);
> return tmp;
> }
>
>
> friend std::ptrdiff_t operator-(const buffers_iterator& a,
> const buffers_iterator& b)
> {
> return b.distance_to(a);
> }
>
>
> friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
> {
> return a.equal(b);
> }
>
>
> friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
> {
> return !a.equal(b);
> }
>
>
> friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
> {
> return a.distance_to(b) > 0;
> }
>
>
> friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
> {
> return !(b < a);
> }
>
>
> friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
> {
> return b < a;
> }
>
>
> friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
> {
> return !(a < b);
> }
>
>private:
>
> reference dereference() const
> {
> return static_cast<pointer>(
> current_buffer_.data())[current_buffer_position_];
> }
>
>
> bool equal(const buffers_iterator& other) const
> {
> return position_ == other.position_;
> }
>
>
> void increment()
> {
> (static_cast <bool> (current_ != end_ && "iterator out of bounds") ? void (0) : __assert_fail ("current_ != end_ && \"iterator out of bounds\"", "/usr/include/boost/asio/buffers_iterator.hpp", 357, __extension__ __PRETTY_FUNCTION__));
> ++position_;
>
>
> ++current_buffer_position_;
> if (current_buffer_position_ != current_buffer_.size())
> return;
>
>
> ++current_;
> current_buffer_position_ = 0;
> while (current_ != end_)
> {
> current_buffer_ = *current_;
> if (current_buffer_.size() > 0)
> return;
> ++current_;
> }
> }
>
>
> void decrement()
> {
> (static_cast <bool> (position_ > 0 && "iterator out of bounds") ? void (0) : __assert_fail ("position_ > 0 && \"iterator out of bounds\"", "/usr/include/boost/asio/buffers_iterator.hpp", 380, __extension__ __PRETTY_FUNCTION__));
> --position_;
>
>
> if (current_buffer_position_ != 0)
> {
> --current_buffer_position_;
> return;
> }
>
>
> buffer_sequence_iterator_type iter = current_;
> while (iter != begin_)
> {
> --iter;
> buffer_type buffer = *iter;
> std::size_t buffer_size = buffer.size();
> if (buffer_size > 0)
> {
> current_ = iter;
> current_buffer_ = buffer;
> current_buffer_position_ = buffer_size - 1;
> return;
> }
> }
> }
>
>
> void advance(std::ptrdiff_t n)
> {
> if (n > 0)
> {
> (static_cast <bool> (current_ != end_ && "iterator out of bounds") ? void (0) : __assert_fail ("current_ != end_ && \"iterator out of bounds\"", "/usr/include/boost/asio/buffers_iterator.hpp", 412, __extension__ __PRETTY_FUNCTION__));
> for (;;)
> {
> std::ptrdiff_t current_buffer_balance
> = current_buffer_.size() - current_buffer_position_;
>
>
> if (current_buffer_balance > n)
> {
> position_ += n;
> current_buffer_position_ += n;
> return;
> }
>
>
> n -= current_buffer_balance;
> position_ += current_buffer_balance;
>
>
>
> if (++current_ == end_)
> {
> (static_cast <bool> (n == 0 && "iterator out of bounds") ? void (0) : __assert_fail ("n == 0 && \"iterator out of bounds\"", "/usr/include/boost/asio/buffers_iterator.hpp", 434, __extension__ __PRETTY_FUNCTION__));
> current_buffer_ = buffer_type();
> current_buffer_position_ = 0;
> return;
> }
> current_buffer_ = *current_;
> current_buffer_position_ = 0;
> }
> }
> else if (n < 0)
> {
> std::size_t abs_n = -n;
> (static_cast <bool> (position_ >= abs_n && "iterator out of bounds") ? void (0) : __assert_fail ("position_ >= abs_n && \"iterator out of bounds\"", "/usr/include/boost/asio/buffers_iterator.hpp", 446, __extension__ __PRETTY_FUNCTION__));
> for (;;)
> {
>
> if (current_buffer_position_ >= abs_n)
> {
> position_ -= abs_n;
> current_buffer_position_ -= abs_n;
> return;
> }
>
>
> abs_n -= current_buffer_position_;
> position_ -= current_buffer_position_;
>
>
> if (current_ == begin_)
> {
> (static_cast <bool> (abs_n == 0 && "iterator out of bounds") ? void (0) : __assert_fail ("abs_n == 0 && \"iterator out of bounds\"", "/usr/include/boost/asio/buffers_iterator.hpp", 464, __extension__ __PRETTY_FUNCTION__));
> current_buffer_position_ = 0;
> return;
> }
>
>
> buffer_sequence_iterator_type iter = current_;
> while (iter != begin_)
> {
> --iter;
> buffer_type buffer = *iter;
> std::size_t buffer_size = buffer.size();
> if (buffer_size > 0)
> {
> current_ = iter;
> current_buffer_ = buffer;
> current_buffer_position_ = buffer_size;
> break;
> }
> }
> }
> }
> }
>
>
> std::ptrdiff_t distance_to(const buffers_iterator& other) const
> {
> return other.position_ - position_;
> }
>
> buffer_type current_buffer_;
> std::size_t current_buffer_position_;
> buffer_sequence_iterator_type begin_;
> buffer_sequence_iterator_type current_;
> buffer_sequence_iterator_type end_;
> std::size_t position_;
>};
>
>
>template <typename BufferSequence>
>inline buffers_iterator<BufferSequence> buffers_begin(
> const BufferSequence& buffers)
>{
> return buffers_iterator<BufferSequence>::begin(buffers);
>}
>
>
>template <typename BufferSequence>
>inline buffers_iterator<BufferSequence> buffers_end(
> const BufferSequence& buffers)
>{
> return buffers_iterator<BufferSequence>::end(buffers);
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 522 "/usr/include/boost/asio/buffers_iterator.hpp" 2 3 4
># 45 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/connect.hpp" 1 3 4
># 24 "/usr/include/boost/asio/connect.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/connect.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> char (&has_iterator_helper(...))[2];
>
> template <typename T>
> char has_iterator_helper(T*, typename T::iterator* = 0);
>
> template <typename T>
> struct has_iterator_typedef
> {
> enum { value = (sizeof((has_iterator_helper)((T*)(0))) == 1) };
> };
>}
>
>
>
>template <typename T>
>struct is_endpoint_sequence
>{
>
>
>
>
> enum
> {
> value = detail::has_iterator_typedef<T>::value
> };
>
>};
># 90 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename EndpointSequence>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type* = 0);
># 127 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename EndpointSequence>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, boost::system::error_code& ec,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type* = 0);
># 159 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename Iterator>
>Iterator connect(basic_socket<Protocol >& s, Iterator begin,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
># 187 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename Iterator>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, boost::system::error_code& ec,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
># 220 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename Iterator>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end);
># 257 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename Iterator>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, boost::system::error_code& ec);
># 312 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, ConnectCondition connect_condition,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type* = 0);
># 380 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, ConnectCondition connect_condition,
> boost::system::error_code& ec,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type* = 0);
># 425 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, ConnectCondition connect_condition,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
># 466 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s, Iterator begin,
> ConnectCondition connect_condition, boost::system::error_code& ec,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
># 527 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s, Iterator begin,
> Iterator end, ConnectCondition connect_condition);
># 595 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> boost::system::error_code& ec);
># 672 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename EndpointSequence, typename RangeConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> const EndpointSequence& endpoints,
> RangeConnectHandler&& handler,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type* = 0);
># 718 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename Iterator, typename IteratorConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, IteratorConnectHandler&& handler,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
># 776 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol ,
> typename Iterator, typename IteratorConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end,
> IteratorConnectHandler&& handler);
># 879 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename EndpointSequence,
> typename ConnectCondition, typename RangeConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, ConnectCondition connect_condition,
> RangeConnectHandler&& handler,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type* = 0);
># 936 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s, Iterator begin,
> ConnectCondition connect_condition,
> IteratorConnectHandler&& handler,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type* = 0);
># 1044 "/usr/include/boost/asio/connect.hpp" 3 4
>template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> IteratorConnectHandler&& handler);
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1058 "/usr/include/boost/asio/connect.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/connect.hpp" 1 3 4
># 30 "/usr/include/boost/asio/impl/connect.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/impl/connect.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> struct default_connect_condition
> {
> template <typename Endpoint>
> bool operator()(const boost::system::error_code&, const Endpoint&)
> {
> return true;
> }
> };
>
> template <typename Protocol, typename Iterator>
> inline typename Protocol::endpoint deref_connect_result(
> Iterator iter, boost::system::error_code& ec)
> {
> return ec ? typename Protocol::endpoint() : *iter;
> }
>
> template <typename T, typename Iterator>
> struct legacy_connect_condition_helper : T
> {
> typedef char (*fallback_func_type)(...);
> operator fallback_func_type() const;
> };
>
> template <typename R, typename Arg1, typename Arg2, typename Iterator>
> struct legacy_connect_condition_helper<R (*)(Arg1, Arg2), Iterator>
> {
> R operator()(Arg1, Arg2) const;
> char operator()(...) const;
> };
>
> template <typename T, typename Iterator>
> struct is_legacy_connect_condition
> {
> static char asio_connect_condition_check(char);
> static char (&asio_connect_condition_check(Iterator))[2];
>
> static const bool value =
> sizeof(asio_connect_condition_check(
> (*static_cast<legacy_connect_condition_helper<T, Iterator>*>(0))(
> *static_cast<const boost::system::error_code*>(0),
> *static_cast<const Iterator*>(0)))) != 1;
> };
>
> template <typename ConnectCondition, typename Iterator>
> inline Iterator call_connect_condition(ConnectCondition& connect_condition,
> const boost::system::error_code& ec, Iterator next, Iterator end,
> typename enable_if<is_legacy_connect_condition<
> ConnectCondition, Iterator>::value>::type* = 0)
> {
> if (next != end)
> return connect_condition(ec, next);
> return end;
> }
>
> template <typename ConnectCondition, typename Iterator>
> inline Iterator call_connect_condition(ConnectCondition& connect_condition,
> const boost::system::error_code& ec, Iterator next, Iterator end,
> typename enable_if<!is_legacy_connect_condition<
> ConnectCondition, Iterator>::value>::type* = 0)
> {
> for (;next != end; ++next)
> if (connect_condition(ec, *next))
> return next;
> return end;
> }
>}
>
>template <typename Protocol , typename EndpointSequence>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type*)
>{
> boost::system::error_code ec;
> typename Protocol::endpoint result = connect(s, endpoints, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol , typename EndpointSequence>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, boost::system::error_code& ec,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type*)
>{
> return detail::deref_connect_result<Protocol>(
> connect(s, endpoints.begin(), endpoints.end(),
> detail::default_connect_condition(), ec), ec);
>}
>
>
>template <typename Protocol , typename Iterator>
>Iterator connect(basic_socket<Protocol >& s, Iterator begin,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol , typename Iterator>
>inline Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, boost::system::error_code& ec,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
>{
> return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
>}
>
>
>template <typename Protocol , typename Iterator>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, end, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol , typename Iterator>
>inline Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, boost::system::error_code& ec)
>{
> return connect(s, begin, end, detail::default_connect_condition(), ec);
>}
>
>template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, ConnectCondition connect_condition,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type*)
>{
> boost::system::error_code ec;
> typename Protocol::endpoint result = connect(
> s, endpoints, connect_condition, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition>
>typename Protocol::endpoint connect(
> basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, ConnectCondition connect_condition,
> boost::system::error_code& ec,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type*)
>{
> return detail::deref_connect_result<Protocol>(
> connect(s, endpoints.begin(), endpoints.end(),
> connect_condition, ec), ec);
>}
>
>
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, ConnectCondition connect_condition,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, connect_condition, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>inline Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, ConnectCondition connect_condition,
> boost::system::error_code& ec,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
>{
> return connect(s, begin, Iterator(), connect_condition, ec);
>}
>
>
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition)
>{
> boost::system::error_code ec;
> Iterator result = connect(s, begin, end, connect_condition, ec);
> boost::asio::detail::throw_error(ec, "connect");
> return result;
>}
>
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition>
>Iterator connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
>
> for (Iterator iter = begin; iter != end; ++iter)
> {
> iter = (detail::call_connect_condition(connect_condition, ec, iter, end));
> if (iter != end)
> {
> s.close(ec);
> s.connect(*iter, ec);
> if (!ec)
> return iter;
> }
> else
> break;
> }
>
> if (!ec)
> ec = boost::asio::error::not_found;
>
> return end;
>}
>
>namespace detail
>{
>
> template <typename ConnectCondition>
> class base_from_connect_condition
> {
> protected:
> explicit base_from_connect_condition(
> const ConnectCondition& connect_condition)
> : connect_condition_(connect_condition)
> {
> }
>
> template <typename Iterator>
> void check_condition(const boost::system::error_code& ec,
> Iterator& iter, Iterator& end)
> {
> iter = detail::call_connect_condition(connect_condition_, ec, iter, end);
> }
>
> private:
> ConnectCondition connect_condition_;
> };
>
>
>
> template <>
> class base_from_connect_condition<default_connect_condition>
> {
> protected:
> explicit base_from_connect_condition(const default_connect_condition&)
> {
> }
>
> template <typename Iterator>
> void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
> {
> }
> };
>
> template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition,
> typename RangeConnectHandler>
> class range_connect_op : base_from_connect_condition<ConnectCondition>
> {
> public:
> range_connect_op(basic_socket<Protocol >& sock,
> const EndpointSequence& endpoints,
> const ConnectCondition& connect_condition,
> RangeConnectHandler& handler)
> : base_from_connect_condition<ConnectCondition>(connect_condition),
> socket_(sock),
> endpoints_(endpoints),
> index_(0),
> start_(0),
> handler_(static_cast<RangeConnectHandler&&>(handler))
> {
> }
>
>
> range_connect_op(const range_connect_op& other)
> : base_from_connect_condition<ConnectCondition>(other),
> socket_(other.socket_),
> endpoints_(other.endpoints_),
> index_(other.index_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> range_connect_op(range_connect_op&& other)
> : base_from_connect_condition<ConnectCondition>(other),
> socket_(other.socket_),
> endpoints_(other.endpoints_),
> index_(other.index_),
> start_(other.start_),
> handler_(static_cast<RangeConnectHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(boost::system::error_code ec, int start = 0)
> {
> typename EndpointSequence::const_iterator begin = endpoints_.begin();
> typename EndpointSequence::const_iterator iter = begin;
> std::advance(iter, index_);
> typename EndpointSequence::const_iterator end = endpoints_.end();
>
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> this->check_condition(ec, iter, end);
> index_ = std::distance(begin, iter);
>
> if (iter != end)
> {
> socket_.close(ec);
> socket_.async_connect(*iter,
> static_cast<range_connect_op&&>(*this));
> return;
> }
>
> if (start)
> {
> ec = boost::asio::error::not_found;
> boost::asio::post(socket_.get_executor(),
> detail::bind_handler(
> static_cast<range_connect_op&&>(*this), ec));
> return;
> }
>
> default:
>
> if (iter == end)
> break;
>
> if (!socket_.is_open())
> {
> ec = boost::asio::error::operation_aborted;
> break;
> }
>
> if (!ec)
> break;
>
> ++iter;
> ++index_;
> }
>
> handler_(static_cast<const boost::system::error_code&>(ec),
> static_cast<const typename Protocol::endpoint&>(
> ec || iter == end ? typename Protocol::endpoint() : *iter));
> }
> }
>
>
> basic_socket<Protocol >& socket_;
> EndpointSequence endpoints_;
> std::size_t index_;
> int start_;
> RangeConnectHandler handler_;
> };
>
> template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition,
> typename RangeConnectHandler>
> inline void* asio_handler_allocate(std::size_t size,
> range_connect_op<Protocol , EndpointSequence,
> ConnectCondition, RangeConnectHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition,
> typename RangeConnectHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> range_connect_op<Protocol , EndpointSequence,
> ConnectCondition, RangeConnectHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition,
> typename RangeConnectHandler>
> inline bool asio_handler_is_continuation(
> range_connect_op<Protocol , EndpointSequence,
> ConnectCondition, RangeConnectHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename Protocol
> , typename EndpointSequence,
> typename ConnectCondition, typename RangeConnectHandler>
> inline void asio_handler_invoke(Function& function,
> range_connect_op<Protocol , EndpointSequence,
> ConnectCondition, RangeConnectHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename Protocol
> , typename EndpointSequence,
> typename ConnectCondition, typename RangeConnectHandler>
> inline void asio_handler_invoke(const Function& function,
> range_connect_op<Protocol , EndpointSequence,
> ConnectCondition, RangeConnectHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
> class iterator_connect_op : base_from_connect_condition<ConnectCondition>
> {
> public:
> iterator_connect_op(basic_socket<Protocol >& sock,
> const Iterator& begin, const Iterator& end,
> const ConnectCondition& connect_condition,
> IteratorConnectHandler& handler)
> : base_from_connect_condition<ConnectCondition>(connect_condition),
> socket_(sock),
> iter_(begin),
> end_(end),
> start_(0),
> handler_(static_cast<IteratorConnectHandler&&>(handler))
> {
> }
>
>
> iterator_connect_op(const iterator_connect_op& other)
> : base_from_connect_condition<ConnectCondition>(other),
> socket_(other.socket_),
> iter_(other.iter_),
> end_(other.end_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> iterator_connect_op(iterator_connect_op&& other)
> : base_from_connect_condition<ConnectCondition>(other),
> socket_(other.socket_),
> iter_(other.iter_),
> end_(other.end_),
> start_(other.start_),
> handler_(static_cast<IteratorConnectHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(boost::system::error_code ec, int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> this->check_condition(ec, iter_, end_);
>
> if (iter_ != end_)
> {
> socket_.close(ec);
> socket_.async_connect(*iter_,
> static_cast<iterator_connect_op&&>(*this));
> return;
> }
>
> if (start)
> {
> ec = boost::asio::error::not_found;
> boost::asio::post(socket_.get_executor(),
> detail::bind_handler(
> static_cast<iterator_connect_op&&>(*this), ec));
> return;
> }
>
> default:
>
> if (iter_ == end_)
> break;
>
> if (!socket_.is_open())
> {
> ec = boost::asio::error::operation_aborted;
> break;
> }
>
> if (!ec)
> break;
>
> ++iter_;
> }
>
> handler_(static_cast<const boost::system::error_code&>(ec),
> static_cast<const Iterator&>(iter_));
> }
> }
>
>
> basic_socket<Protocol >& socket_;
> Iterator iter_;
> Iterator end_;
> int start_;
> IteratorConnectHandler handler_;
> };
>
> template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
> inline void* asio_handler_allocate(std::size_t size,
> iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
> inline bool asio_handler_is_continuation(
> iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename Protocol
> , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
> inline void asio_handler_invoke(Function& function,
> iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename Protocol
> , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
> inline void asio_handler_invoke(const Function& function,
> iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition,
> typename RangeConnectHandler, typename Allocator>
>struct associated_allocator<
> detail::range_connect_op<Protocol ,
> EndpointSequence, ConnectCondition, RangeConnectHandler>,
> Allocator>
>{
> typedef typename associated_allocator<
> RangeConnectHandler, Allocator>::type type;
>
> static type get(
> const detail::range_connect_op<Protocol ,
> EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<RangeConnectHandler,
> Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Protocol ,
> typename EndpointSequence, typename ConnectCondition,
> typename RangeConnectHandler, typename Executor>
>struct associated_executor<
> detail::range_connect_op<Protocol ,
> EndpointSequence, ConnectCondition, RangeConnectHandler>,
> Executor>
>{
> typedef typename associated_executor<
> RangeConnectHandler, Executor>::type type;
>
> static type get(
> const detail::range_connect_op<Protocol ,
> EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<RangeConnectHandler,
> Executor>::get(h.handler_, ex);
> }
>};
>
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition,
> typename IteratorConnectHandler, typename Allocator>
>struct associated_allocator<
> detail::iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>,
> Allocator>
>{
> typedef typename associated_allocator<
> IteratorConnectHandler, Allocator>::type type;
>
> static type get(
> const detail::iterator_connect_op<Protocol ,
> Iterator, ConnectCondition, IteratorConnectHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<IteratorConnectHandler,
> Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Protocol ,
> typename Iterator, typename ConnectCondition,
> typename IteratorConnectHandler, typename Executor>
>struct associated_executor<
> detail::iterator_connect_op<Protocol , Iterator,
> ConnectCondition, IteratorConnectHandler>,
> Executor>
>{
> typedef typename associated_executor<
> IteratorConnectHandler, Executor>::type type;
>
> static type get(
> const detail::iterator_connect_op<Protocol ,
> Iterator, ConnectCondition, IteratorConnectHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<IteratorConnectHandler,
> Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename Protocol ,
> typename EndpointSequence, typename RangeConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> const EndpointSequence& endpoints,
> RangeConnectHandler&& handler,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void(boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const typename Protocol::endpoint*>(0))) == 1, "RangeConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const typename Protocol::endpoint>()), char(0))> __attribute__((__unused__))
> type_check;
>
> async_completion<RangeConnectHandler,
> void (boost::system::error_code, typename Protocol::endpoint)>
> init(handler);
>
> detail::range_connect_op<Protocol , EndpointSequence,
> detail::default_connect_condition,
> typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type
> >(s,
> endpoints, detail::default_connect_condition(),
> init.completion_handler)(boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>
>template <typename Protocol ,
> typename Iterator, typename IteratorConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, IteratorConnectHandler&& handler,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
> type_check;
>
> async_completion<IteratorConnectHandler,
> void (boost::system::error_code, Iterator)> init(handler);
>
> detail::iterator_connect_op<Protocol , Iterator,
> detail::default_connect_condition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
> >(s,
> begin, Iterator(), detail::default_connect_condition(),
> init.completion_handler)(boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>
>template <typename Protocol ,
> typename Iterator, typename IteratorConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end,
> IteratorConnectHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
> type_check;
>
> async_completion<IteratorConnectHandler,
> void (boost::system::error_code, Iterator)> init(handler);
>
> detail::iterator_connect_op<Protocol , Iterator,
> detail::default_connect_condition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
> >(s,
> begin, end, detail::default_connect_condition(),
> init.completion_handler)(boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>template <typename Protocol , typename EndpointSequence,
> typename ConnectCondition, typename RangeConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> const EndpointSequence& endpoints, ConnectCondition connect_condition,
> RangeConnectHandler&& handler,
> typename enable_if<is_endpoint_sequence<
> EndpointSequence>::value>::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void(boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const typename Protocol::endpoint*>(0))) == 1, "RangeConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const typename Protocol::endpoint>()), char(0))> __attribute__((__unused__))
> type_check;
>
> async_completion<RangeConnectHandler,
> void (boost::system::error_code, typename Protocol::endpoint)>
> init(handler);
>
> detail::range_connect_op<Protocol , EndpointSequence,
> ConnectCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<RangeConnectHandler>::type, void (boost::system::error_code, typename Protocol::endpoint)>::completion_handler_type
> >(s,
> endpoints, connect_condition, init.completion_handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>
>template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, ConnectCondition connect_condition,
> IteratorConnectHandler&& handler,
> typename enable_if<!is_endpoint_sequence<Iterator>::value>::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
> type_check;
>
> async_completion<IteratorConnectHandler,
> void (boost::system::error_code, Iterator)> init(handler);
>
> detail::iterator_connect_op<Protocol , Iterator,
> ConnectCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
> >(s,
> begin, Iterator(), connect_condition, init.completion_handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>
>template <typename Protocol , typename Iterator,
> typename ConnectCondition, typename IteratorConnectHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::return_type
>
>async_connect(basic_socket<Protocol >& s,
> Iterator begin, Iterator end, ConnectCondition connect_condition,
> IteratorConnectHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void(boost::system::error_code, Iterator)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const Iterator*>(0))) == 1, "IteratorConnectHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const Iterator>()), char(0))> __attribute__((__unused__))
> type_check;
>
> async_completion<IteratorConnectHandler,
> void (boost::system::error_code, Iterator)> init(handler);
>
> detail::iterator_connect_op<Protocol , Iterator,
> ConnectCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<IteratorConnectHandler>::type, void (boost::system::error_code, Iterator)>::completion_handler_type
> >(s,
> begin, end, connect_condition, init.completion_handler)(
> boost::system::error_code(), 1);
>
> return init.result.get();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 861 "/usr/include/boost/asio/impl/connect.hpp" 2 3 4
># 1060 "/usr/include/boost/asio/connect.hpp" 2 3 4
># 47 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/coroutine.hpp" 1 3 4
># 14 "/usr/include/boost/asio/coroutine.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>class coroutine_ref;
>
>}
># 242 "/usr/include/boost/asio/coroutine.hpp" 3 4
>class coroutine
>{
>public:
>
> coroutine() : value_(0) {}
>
>
> bool is_child() const { return value_ < 0; }
>
>
> bool is_parent() const { return !is_child(); }
>
>
> bool is_complete() const { return value_ == -1; }
>
>private:
> friend class detail::coroutine_ref;
> int value_;
>};
>
>
>namespace detail {
>
>class coroutine_ref
>{
>public:
> coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
> coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
> ~coroutine_ref() { if (!modified_) value_ = -1; }
> operator int() const { return value_; }
> int& operator=(int v) { modified_ = true; return value_ = v; }
>private:
> void operator=(const coroutine_ref&);
> int& value_;
> bool modified_;
>};
>
>}
>}
>}
># 48 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/datagram_socket_service.hpp" 1 3 4
># 49 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/deadline_timer_service.hpp" 1 3 4
># 50 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/deadline_timer.hpp" 1 3 4
># 28 "/usr/include/boost/asio/deadline_timer.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
>
>}
>}
># 51 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/defer.hpp" 1 3 4
># 24 "/usr/include/boost/asio/defer.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/defer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 53 "/usr/include/boost/asio/defer.hpp" 3 4
>template <typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
> CompletionToken&& token);
># 87 "/usr/include/boost/asio/defer.hpp" 3 4
>template <typename Executor, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
> const Executor& ex, CompletionToken&& token,
> typename enable_if<is_executor<Executor>::value>::type* = 0);
>
>
>
>
>
>template <typename ExecutionContext, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
> ExecutionContext& ctx, CompletionToken&& token,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type* = 0);
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 106 "/usr/include/boost/asio/defer.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/defer.hpp" 1 3 4
># 23 "/usr/include/boost/asio/impl/defer.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/impl/defer.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
> CompletionToken&& token)
>{
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;
>
> async_completion<CompletionToken, void()> init(token);
>
> typename associated_executor<handler>::type ex(
> (get_associated_executor)(init.completion_handler));
>
> typename associated_allocator<handler>::type alloc(
> (get_associated_allocator)(init.completion_handler));
>
> ex.defer(static_cast<handler&&>(init.completion_handler), alloc);
>
> return init.result.get();
>}
>
>template <typename Executor, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
> const Executor& ex, CompletionToken&& token,
> typename enable_if<is_executor<Executor>::value>::type*)
>{
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;
>
> async_completion<CompletionToken, void()> init(token);
>
> typename associated_allocator<handler>::type alloc(
> (get_associated_allocator)(init.completion_handler));
>
> ex.defer(detail::work_dispatcher<handler>(init.completion_handler), alloc);
>
> return init.result.get();
>}
>
>template <typename ExecutionContext, typename CompletionToken>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type defer(
> ExecutionContext& ctx, CompletionToken&& token,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type*)
>{
> return (defer)(ctx.get_executor(),
> static_cast<CompletionToken&&>(token));
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 78 "/usr/include/boost/asio/impl/defer.hpp" 2 3 4
># 108 "/usr/include/boost/asio/defer.hpp" 2 3 4
># 52 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/dispatch.hpp" 1 3 4
># 24 "/usr/include/boost/asio/dispatch.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/dispatch.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 53 "/usr/include/boost/asio/dispatch.hpp" 3 4
>template <typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
> CompletionToken&& token);
># 87 "/usr/include/boost/asio/dispatch.hpp" 3 4
>template <typename Executor, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
> const Executor& ex, CompletionToken&& token,
> typename enable_if<is_executor<Executor>::value>::type* = 0);
>
>
>
>
>
>
>template <typename ExecutionContext, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
> ExecutionContext& ctx, CompletionToken&& token,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type* = 0);
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 107 "/usr/include/boost/asio/dispatch.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/dispatch.hpp" 1 3 4
># 23 "/usr/include/boost/asio/impl/dispatch.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/impl/dispatch.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
> CompletionToken&& token)
>{
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;
>
> async_completion<CompletionToken, void()> init(token);
>
> typename associated_executor<handler>::type ex(
> (get_associated_executor)(init.completion_handler));
>
> typename associated_allocator<handler>::type alloc(
> (get_associated_allocator)(init.completion_handler));
>
> ex.dispatch(static_cast<handler&&>(init.completion_handler), alloc);
>
> return init.result.get();
>}
>
>template <typename Executor, typename CompletionToken>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
> const Executor& ex, CompletionToken&& token,
> typename enable_if<is_executor<Executor>::value>::type*)
>{
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::completion_handler_type handler;
>
> async_completion<CompletionToken, void()> init(token);
>
> typename associated_allocator<handler>::type alloc(
> (get_associated_allocator)(init.completion_handler));
>
> ex.dispatch(detail::work_dispatcher<handler>(
> init.completion_handler), alloc);
>
> return init.result.get();
>}
>
>template <typename ExecutionContext, typename CompletionToken>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionToken>::type, void()>::return_type dispatch(
> ExecutionContext& ctx, CompletionToken&& token,
> typename enable_if<is_convertible<
> ExecutionContext&, execution_context&>::value>::type*)
>{
> return (dispatch)(ctx.get_executor(),
> static_cast<CompletionToken&&>(token));
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 79 "/usr/include/boost/asio/impl/dispatch.hpp" 2 3 4
># 109 "/usr/include/boost/asio/dispatch.hpp" 2 3 4
># 53 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/executor.hpp" 1 3 4
># 20 "/usr/include/boost/asio/executor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/cstddef.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/cstddef.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>using std::nullptr_t;
>
>
>
>
>}
>}
># 21 "/usr/include/boost/asio/executor.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>class bad_executor
> : public std::exception
>{
>public:
>
> inline bad_executor() noexcept;
>
>
> inline virtual const char* what() const
> noexcept;
>};
>
>
>class executor
>{
>public:
>
> executor() noexcept
> : impl_(0)
> {
> }
>
>
> executor(nullptr_t) noexcept
> : impl_(0)
> {
> }
>
>
> executor(const executor& other) noexcept
> : impl_(other.clone())
> {
> }
>
>
>
> executor(executor&& other) noexcept
> : impl_(other.impl_)
> {
> other.impl_ = 0;
> }
>
>
>
> template <typename Executor>
> executor(Executor e);
>
>
>
> template <typename Executor, typename Allocator>
> executor(allocator_arg_t, const Allocator& a, Executor e);
>
>
> ~executor()
> {
> destroy();
> }
>
>
> executor& operator=(const executor& other) noexcept
> {
> destroy();
> impl_ = other.clone();
> return *this;
> }
>
>
>
> executor& operator=(executor&& other) noexcept
> {
> destroy();
> impl_ = other.impl_;
> other.impl_ = 0;
> return *this;
> }
>
>
>
> executor& operator=(nullptr_t) noexcept
> {
> destroy();
> impl_ = 0;
> return *this;
> }
>
>
>
> template <typename Executor>
> executor& operator=(Executor&& e) noexcept
> {
> executor tmp(static_cast<Executor&&>(e));
> destroy();
> impl_ = tmp.impl_;
> tmp.impl_ = 0;
> return *this;
> }
>
>
> execution_context& context() const noexcept
> {
> return get_impl()->context();
> }
>
>
> void on_work_started() const noexcept
> {
> get_impl()->on_work_started();
> }
>
>
> void on_work_finished() const noexcept
> {
> get_impl()->on_work_finished();
> }
># 159 "/usr/include/boost/asio/executor.hpp" 3 4
> template <typename Function, typename Allocator>
> void dispatch(Function&& f, const Allocator& a) const;
># 175 "/usr/include/boost/asio/executor.hpp" 3 4
> template <typename Function, typename Allocator>
> void post(Function&& f, const Allocator& a) const;
># 191 "/usr/include/boost/asio/executor.hpp" 3 4
> template <typename Function, typename Allocator>
> void defer(Function&& f, const Allocator& a) const;
>
> struct unspecified_bool_type_t {};
> typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
> static void unspecified_bool_true(unspecified_bool_type_t) {}
>
>
> operator unspecified_bool_type() const noexcept
> {
> return impl_ ? &executor::unspecified_bool_true : 0;
> }
>
>
>
>
>
>
>
> const std::type_info& target_type() const noexcept
> {
> return impl_ ? impl_->target_type() : typeid(void);
> }
># 226 "/usr/include/boost/asio/executor.hpp" 3 4
> template <typename Executor>
> Executor* target() noexcept;
>
>
>
>
>
>
> template <typename Executor>
> const Executor* target() const noexcept;
>
>
> friend bool operator==(const executor& a,
> const executor& b) noexcept
> {
> if (a.impl_ == b.impl_)
> return true;
> if (!a.impl_ || !b.impl_)
> return false;
> return a.impl_->equals(b.impl_);
> }
>
>
> friend bool operator!=(const executor& a,
> const executor& b) noexcept
> {
> return !(a == b);
> }
>
>private:
>
> class function;
> template <typename, typename> class impl;
>
>
> typedef const std::type_info& type_id_result_type;
>
>
>
>
> template <typename T>
> static type_id_result_type type_id()
> {
>
> return typeid(T);
>
>
>
>
> }
>
>
> class impl_base
> {
> public:
> virtual impl_base* clone() const noexcept = 0;
> virtual void destroy() noexcept = 0;
> virtual execution_context& context() noexcept = 0;
> virtual void on_work_started() noexcept = 0;
> virtual void on_work_finished() noexcept = 0;
> virtual void dispatch(function&&) = 0;
> virtual void post(function&&) = 0;
> virtual void defer(function&&) = 0;
> virtual type_id_result_type target_type() const noexcept = 0;
> virtual void* target() noexcept = 0;
> virtual const void* target() const noexcept = 0;
> virtual bool equals(const impl_base* e) const noexcept = 0;
>
> protected:
> impl_base(bool fast_dispatch) : fast_dispatch_(fast_dispatch) {}
> virtual ~impl_base() {}
>
> private:
> friend class executor;
> const bool fast_dispatch_;
> };
>
>
> impl_base* get_impl() const
> {
> if (!impl_)
> {
> bad_executor ex;
> boost::asio::detail::throw_exception(ex);
> }
> return impl_;
> }
>
>
> impl_base* clone() const noexcept
> {
> return impl_ ? impl_->clone() : 0;
> }
>
>
> void destroy() noexcept
> {
> if (impl_)
> impl_->destroy();
> }
>
> impl_base* impl_;
>
>};
>
>}
>}
>
>namespace std { template <typename Allocator> struct uses_allocator<boost::asio::executor, Allocator> : true_type {}; }
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 337 "/usr/include/boost/asio/executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/executor.hpp" 1 3 4
># 24 "/usr/include/boost/asio/impl/executor.hpp" 3 4
># 1 "/usr/include/boost/asio/executor.hpp" 1 3 4
># 25 "/usr/include/boost/asio/impl/executor.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/impl/executor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>
>
>
>class executor::function
>{
>public:
> template <typename F, typename Alloc>
> explicit function(F f, const Alloc& a)
> {
>
> typedef detail::executor_op<F, Alloc> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> op_ = new (p.v) op(static_cast<F&&>(f), a);
> p.v = 0;
> }
>
> function(function&& other)
> : op_(other.op_)
> {
> other.op_ = 0;
> }
>
> ~function()
> {
> if (op_)
> op_->destroy();
> }
>
> void operator()()
> {
> if (op_)
> {
> detail::scheduler_operation* op = op_;
> op_ = 0;
> op->complete(this, boost::system::error_code(), 0);
> }
> }
>
>private:
> detail::scheduler_operation* op_;
>};
># 126 "/usr/include/boost/asio/impl/executor.hpp" 3 4
>template <typename Executor, typename Allocator>
>class executor::impl
> : public executor::impl_base
>{
>public:
> typedef typename std::allocator_traits<Allocator>::template rebind_alloc<impl> allocator_type;
>
> static impl_base* create(const Executor& e, Allocator a = Allocator())
> {
> raw_mem mem(a);
> impl* p = new (mem.ptr_) impl(e, a);
> mem.ptr_ = 0;
> return p;
> }
>
> impl(const Executor& e, const Allocator& a) noexcept
> : impl_base(false),
> ref_count_(1),
> executor_(e),
> allocator_(a)
> {
> }
>
> impl_base* clone() const noexcept
> {
> ++ref_count_;
> return const_cast<impl_base*>(static_cast<const impl_base*>(this));
> }
>
> void destroy() noexcept
> {
> if (--ref_count_ == 0)
> {
> allocator_type alloc(allocator_);
> impl* p = this;
> p->~impl();
> alloc.deallocate(p, 1);
> }
> }
>
> void on_work_started() noexcept
> {
> executor_.on_work_started();
> }
>
> void on_work_finished() noexcept
> {
> executor_.on_work_finished();
> }
>
> execution_context& context() noexcept
> {
> return executor_.context();
> }
>
> void dispatch(function&& f)
> {
> executor_.dispatch(static_cast<function&&>(f), allocator_);
> }
>
> void post(function&& f)
> {
> executor_.post(static_cast<function&&>(f), allocator_);
> }
>
> void defer(function&& f)
> {
> executor_.defer(static_cast<function&&>(f), allocator_);
> }
>
> type_id_result_type target_type() const noexcept
> {
> return type_id<Executor>();
> }
>
> void* target() noexcept
> {
> return &executor_;
> }
>
> const void* target() const noexcept
> {
> return &executor_;
> }
>
> bool equals(const impl_base* e) const noexcept
> {
> if (this == e)
> return true;
> if (target_type() != e->target_type())
> return false;
> return executor_ == *static_cast<const Executor*>(e->target());
> }
>
>private:
> mutable detail::atomic_count ref_count_;
> Executor executor_;
> Allocator allocator_;
>
> struct raw_mem
> {
> allocator_type allocator_;
> impl* ptr_;
>
> explicit raw_mem(const Allocator& a)
> : allocator_(a),
> ptr_(allocator_.allocate(1))
> {
> }
>
> ~raw_mem()
> {
> if (ptr_)
> allocator_.deallocate(ptr_, 1);
> }
>
> private:
>
> raw_mem(const raw_mem&);
> raw_mem operator=(const raw_mem&);
> };
>};
>
>
>template <typename Allocator>
>class executor::impl<system_executor, Allocator>
> : public executor::impl_base
>{
>public:
> static impl_base* create(const system_executor&,
> const Allocator& = Allocator())
> {
> return &detail::global<impl<system_executor, std::allocator<void> > >();
> }
>
> impl()
> : impl_base(true)
> {
> }
>
> impl_base* clone() const noexcept
> {
> return const_cast<impl_base*>(static_cast<const impl_base*>(this));
> }
>
> void destroy() noexcept
> {
> }
>
> void on_work_started() noexcept
> {
> executor_.on_work_started();
> }
>
> void on_work_finished() noexcept
> {
> executor_.on_work_finished();
> }
>
> execution_context& context() noexcept
> {
> return executor_.context();
> }
>
> void dispatch(function&& f)
> {
> executor_.dispatch(static_cast<function&&>(f), allocator_);
> }
>
> void post(function&& f)
> {
> executor_.post(static_cast<function&&>(f), allocator_);
> }
>
> void defer(function&& f)
> {
> executor_.defer(static_cast<function&&>(f), allocator_);
> }
>
> type_id_result_type target_type() const noexcept
> {
> return type_id<system_executor>();
> }
>
> void* target() noexcept
> {
> return &executor_;
> }
>
> const void* target() const noexcept
> {
> return &executor_;
> }
>
> bool equals(const impl_base* e) const noexcept
> {
> return this == e;
> }
>
>private:
> system_executor executor_;
> Allocator allocator_;
>};
>
>template <typename Executor>
>executor::executor(Executor e)
> : impl_(impl<Executor, std::allocator<void> >::create(e))
>{
>}
>
>template <typename Executor, typename Allocator>
>executor::executor(allocator_arg_t, const Allocator& a, Executor e)
> : impl_(impl<Executor, Allocator>::create(e, a))
>{
>}
>
>template <typename Function, typename Allocator>
>void executor::dispatch(Function&& f,
> const Allocator& a) const
>{
> impl_base* i = get_impl();
> if (i->fast_dispatch_)
> system_executor().dispatch(static_cast<Function&&>(f), a);
> else
> i->dispatch(function(static_cast<Function&&>(f), a));
>}
>
>template <typename Function, typename Allocator>
>void executor::post(Function&& f,
> const Allocator& a) const
>{
> get_impl()->post(function(static_cast<Function&&>(f), a));
>}
>
>template <typename Function, typename Allocator>
>void executor::defer(Function&& f,
> const Allocator& a) const
>{
> get_impl()->defer(function(static_cast<Function&&>(f), a));
>}
>
>template <typename Executor>
>Executor* executor::target() noexcept
>{
> return impl_ && impl_->target_type() == type_id<Executor>()
> ? static_cast<Executor*>(impl_->target()) : 0;
>}
>
>template <typename Executor>
>const Executor* executor::target() const noexcept
>{
> return impl_ && impl_->target_type() == type_id<Executor>()
> ? static_cast<Executor*>(impl_->target()) : 0;
>}
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 387 "/usr/include/boost/asio/impl/executor.hpp" 2 3 4
># 339 "/usr/include/boost/asio/executor.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/executor.ipp" 1 3 4
># 21 "/usr/include/boost/asio/impl/executor.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/impl/executor.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>bad_executor::bad_executor() noexcept
>{
>}
>
>const char* bad_executor::what() const noexcept
>{
> return "bad executor";
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 39 "/usr/include/boost/asio/impl/executor.ipp" 2 3 4
># 341 "/usr/include/boost/asio/executor.hpp" 2 3 4
># 56 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 1 3 4
># 19 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 1 3 4
># 23 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
>namespace detail {
>
>
>class endpoint
>{
>public:
>
> inline endpoint();
>
>
> inline endpoint(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol);
>
>
> endpoint(const endpoint& other)
> : data_(other.data_),
> size_(other.size_),
> protocol_(other.protocol_)
> {
> }
>
>
> endpoint& operator=(const endpoint& other)
> {
> data_ = other.data_;
> size_ = other.size_;
> protocol_ = other.protocol_;
> return *this;
> }
>
>
> int family() const
> {
> return data_.base.sa_family;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> boost::asio::detail::socket_addr_type* data()
> {
> return &data_.base;
> }
>
>
> const boost::asio::detail::socket_addr_type* data() const
> {
> return &data_.base;
> }
>
>
> std::size_t size() const
> {
> return size_;
> }
>
>
> inline void resize(std::size_t size);
>
>
> std::size_t capacity() const
> {
> return sizeof(boost::asio::detail::sockaddr_storage_type);
> }
>
>
> inline friend bool operator==(
> const endpoint& e1, const endpoint& e2);
>
>
> inline friend bool operator<(
> const endpoint& e1, const endpoint& e2);
>
>private:
>
> union data_union
> {
> boost::asio::detail::socket_addr_type base;
> boost::asio::detail::sockaddr_storage_type generic;
> } data_;
>
>
> std::size_t size_;
>
>
> int protocol_;
>
>
> inline void init(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol);
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 130 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 1 3 4
># 20 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 21 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
>namespace detail {
>
>endpoint::endpoint()
>{
> init(0, 0, 0);
>}
>
>endpoint::endpoint(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol)
>{
> init(sock_addr, sock_addr_size, sock_protocol);
>}
>
>void endpoint::resize(std::size_t new_size)
>{
> if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
> else
> {
> size_ = new_size;
> protocol_ = 0;
> }
>}
>
>bool operator==(const endpoint& e1, const endpoint& e2)
>{
> using namespace std;
> return e1.size() == e2.size() && memcmp(e1.data(), e2.data(), e1.size()) == 0;
>}
>
>bool operator<(const endpoint& e1, const endpoint& e2)
>{
> if (e1.protocol() < e2.protocol())
> return true;
>
> if (e1.protocol() > e2.protocol())
> return false;
>
> using namespace std;
> std::size_t compare_size = e1.size() < e2.size() ? e1.size() : e2.size();
> int compare_result = memcmp(e1.data(), e2.data(), compare_size);
>
> if (compare_result < 0)
> return true;
>
> if (compare_result > 0)
> return false;
>
> return e1.size() < e2.size();
>}
>
>void endpoint::init(const void* sock_addr,
> std::size_t sock_addr_size, int sock_protocol)
>{
> if (sock_addr_size > sizeof(boost::asio::detail::sockaddr_storage_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
>
> using namespace std;
> memset(&data_.generic, 0, sizeof(boost::asio::detail::sockaddr_storage_type));
> if (sock_addr_size > 0)
> memcpy(&data_.generic, sock_addr, sock_addr_size);
>
> size_ = sock_addr_size;
> protocol_ = sock_protocol;
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 111 "/usr/include/boost/asio/generic/detail/impl/endpoint.ipp" 2 3 4
># 133 "/usr/include/boost/asio/generic/detail/endpoint.hpp" 2 3 4
># 20 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 42 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 3 4
>template <typename Protocol>
>class basic_endpoint
>{
>public:
>
> typedef Protocol protocol_type;
>
>
>
>
>
>
> typedef boost::asio::detail::socket_addr_type data_type;
>
>
>
> basic_endpoint()
> {
> }
>
>
> basic_endpoint(const void* socket_address,
> std::size_t socket_address_size, int socket_protocol = 0)
> : impl_(socket_address, socket_address_size, socket_protocol)
> {
> }
>
>
> template <typename Endpoint>
> basic_endpoint(const Endpoint& endpoint)
> : impl_(endpoint.data(), endpoint.size(), endpoint.protocol().protocol())
> {
> }
>
>
> basic_endpoint(const basic_endpoint& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint(basic_endpoint&& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint& operator=(const basic_endpoint& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> basic_endpoint& operator=(basic_endpoint&& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> protocol_type protocol() const
> {
> return protocol_type(impl_.family(), impl_.protocol());
> }
>
>
> data_type* data()
> {
> return impl_.data();
> }
>
>
> const data_type* data() const
> {
> return impl_.data();
> }
>
>
> std::size_t size() const
> {
> return impl_.size();
> }
>
>
> void resize(std::size_t new_size)
> {
> impl_.resize(new_size);
> }
>
>
> std::size_t capacity() const
> {
> return impl_.capacity();
> }
>
>
> friend bool operator==(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ == e2.impl_;
> }
>
>
> friend bool operator!=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1.impl_ == e2.impl_);
> }
>
>
> friend bool operator<(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ < e2.impl_;
> }
>
>
> friend bool operator>(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e2.impl_ < e1.impl_;
> }
>
>
> friend bool operator<=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e2 < e1);
> }
>
>
> friend bool operator>=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1 < e2);
> }
>
>private:
>
> boost::asio::generic::detail::endpoint impl_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 194 "/usr/include/boost/asio/generic/basic_endpoint.hpp" 2 3 4
># 58 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 1 3 4
># 26 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 50 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 3 4
>class datagram_protocol
>{
>public:
>
> datagram_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
> template <typename Protocol>
> datagram_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_DGRAM;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const datagram_protocol& p1,
> const datagram_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const datagram_protocol& p1,
> const datagram_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<datagram_protocol> endpoint;
>
>
> typedef basic_datagram_socket<datagram_protocol> socket;
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 124 "/usr/include/boost/asio/generic/datagram_protocol.hpp" 2 3 4
># 59 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/raw_protocol.hpp" 1 3 4
># 26 "/usr/include/boost/asio/generic/raw_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/generic/raw_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 50 "/usr/include/boost/asio/generic/raw_protocol.hpp" 3 4
>class raw_protocol
>{
>public:
>
> raw_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
> template <typename Protocol>
> raw_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_RAW;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<raw_protocol> endpoint;
>
>
> typedef basic_raw_socket<raw_protocol> socket;
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 122 "/usr/include/boost/asio/generic/raw_protocol.hpp" 2 3 4
># 60 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 1 3 4
># 26 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 48 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 3 4
>class seq_packet_protocol
>{
>public:
>
> seq_packet_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
>
> template <typename Protocol>
> seq_packet_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_SEQPACKET;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const seq_packet_protocol& p1,
> const seq_packet_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const seq_packet_protocol& p1,
> const seq_packet_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<seq_packet_protocol> endpoint;
>
>
> typedef basic_seq_packet_socket<seq_packet_protocol> socket;
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 123 "/usr/include/boost/asio/generic/seq_packet_protocol.hpp" 2 3 4
># 61 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/generic/stream_protocol.hpp" 1 3 4
># 27 "/usr/include/boost/asio/generic/stream_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/generic/stream_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace generic {
># 51 "/usr/include/boost/asio/generic/stream_protocol.hpp" 3 4
>class stream_protocol
>{
>public:
>
> stream_protocol(int address_family, int socket_protocol)
> : family_(address_family),
> protocol_(socket_protocol)
> {
> }
>
>
>
>
>
> template <typename Protocol>
> stream_protocol(const Protocol& source_protocol)
> : family_(source_protocol.family()),
> protocol_(source_protocol.protocol())
> {
> if (source_protocol.type() != type())
> {
> std::bad_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> int type() const
> {
> return SOCK_STREAM;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
> {
> return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
> }
>
>
> friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
> {
> return !(p1 == p2);
> }
>
>
> typedef basic_endpoint<stream_protocol> endpoint;
>
>
> typedef basic_stream_socket<stream_protocol> socket;
>
>
>
> typedef basic_socket_iostream<stream_protocol> iostream;
>
>
>private:
> int family_;
> int protocol_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 128 "/usr/include/boost/asio/generic/stream_protocol.hpp" 2 3 4
># 62 "/usr/include/boost/asio.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/high_resolution_timer.hpp" 1 3 4
># 25 "/usr/include/boost/asio/high_resolution_timer.hpp" 3 4
>namespace boost {
>namespace asio {
># 37 "/usr/include/boost/asio/high_resolution_timer.hpp" 3 4
>typedef basic_waitable_timer<
> chrono::high_resolution_clock>
> high_resolution_timer;
>
>}
>}
># 67 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/io_context_strand.hpp" 1 3 4
># 24 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/strand_service.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/strand_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class strand_service
> : public boost::asio::detail::service_base<strand_service>
>{
>private:
>
> struct on_do_complete_exit;
>
>
> struct on_dispatch_exit;
>
>public:
>
>
> class strand_impl
> : public operation
> {
> public:
> strand_impl();
>
> private:
>
> friend class strand_service;
> friend struct on_do_complete_exit;
> friend struct on_dispatch_exit;
>
>
> boost::asio::detail::mutex mutex_;
>
>
>
>
> bool locked_;
>
>
>
>
> op_queue<operation> waiting_queue_;
>
>
>
>
> op_queue<operation> ready_queue_;
> };
>
> typedef strand_impl* implementation_type;
>
>
> inline explicit strand_service(boost::asio::io_context& io_context);
>
>
> inline void shutdown();
>
>
> inline void construct(implementation_type& impl);
>
>
> template <typename Handler>
> void dispatch(implementation_type& impl, Handler& handler);
>
>
> template <typename Handler>
> void post(implementation_type& impl, Handler& handler);
>
>
> inline bool running_in_this_thread(
> const implementation_type& impl) const;
>
>private:
>
>
> inline bool do_dispatch(implementation_type& impl, operation* op);
>
>
> inline void do_post(implementation_type& impl,
> operation* op, bool is_continuation);
>
> inline static void do_complete(void* owner,
> operation* base, const boost::system::error_code& ec,
> std::size_t bytes_transferred);
>
>
> io_context_impl& io_context_;
>
>
> boost::asio::detail::mutex mutex_;
>
>
>
>
>
> enum { num_implementations = 193 };
>
>
>
> scoped_ptr<strand_impl> implementations_[num_implementations];
>
>
>
> std::size_t salt_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 138 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>inline strand_service::strand_impl::strand_impl()
> : operation(&strand_service::do_complete),
> locked_(false)
>{
>}
>
>struct strand_service::on_dispatch_exit
>{
> io_context_impl* io_context_;
> strand_impl* impl_;
>
> ~on_dispatch_exit()
> {
> impl_->mutex_.lock();
> impl_->ready_queue_.push(impl_->waiting_queue_);
> bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
> impl_->mutex_.unlock();
>
> if (more_handlers)
> io_context_->post_immediate_completion(impl_, false);
> }
>};
>
>template <typename Handler>
>void strand_service::dispatch(strand_service::implementation_type& impl,
> Handler& handler)
>{
>
> if (call_stack<strand_impl>::contains(impl))
> {
> fenced_block b(fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(handler, handler);
> return;
> }
>
>
> typedef completion_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> bool dispatch_immediately = do_dispatch(impl, p.p);
> operation* o = p.p;
> p.v = p.p = 0;
>
> if (dispatch_immediately)
> {
>
> call_stack<strand_impl>::context ctx(impl);
>
>
> on_dispatch_exit on_exit = { &io_context_, impl };
> (void)on_exit;
>
> completion_handler<Handler>::do_complete(
> &io_context_, o, boost::system::error_code(), 0);
> }
>}
>
>
>template <typename Handler>
>void strand_service::post(strand_service::implementation_type& impl,
> Handler& handler)
>{
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef completion_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> do_post(impl, p.p, is_continuation);
> p.v = p.p = 0;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 119 "/usr/include/boost/asio/detail/impl/strand_service.hpp" 2 3 4
># 140 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/strand_service.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct strand_service::on_do_complete_exit
>{
> io_context_impl* owner_;
> strand_impl* impl_;
>
> ~on_do_complete_exit()
> {
> impl_->mutex_.lock();
> impl_->ready_queue_.push(impl_->waiting_queue_);
> bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
> impl_->mutex_.unlock();
>
> if (more_handlers)
> owner_->post_immediate_completion(impl_, true);
> }
>};
>
>strand_service::strand_service(boost::asio::io_context& io_context)
> : boost::asio::detail::service_base<strand_service>(io_context),
> io_context_(boost::asio::use_service<io_context_impl>(io_context)),
> mutex_(),
> salt_(0)
>{
>}
>
>void strand_service::shutdown()
>{
> op_queue<operation> ops;
>
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> for (std::size_t i = 0; i < num_implementations; ++i)
> {
> if (strand_impl* impl = implementations_[i].get())
> {
> ops.push(impl->waiting_queue_);
> ops.push(impl->ready_queue_);
> }
> }
>}
>
>void strand_service::construct(strand_service::implementation_type& impl)
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> std::size_t salt = salt_++;
>
>
>
> std::size_t index = reinterpret_cast<std::size_t>(&impl);
> index += (reinterpret_cast<std::size_t>(&impl) >> 3);
> index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2);
>
> index = index % num_implementations;
>
> if (!implementations_[index].get())
> implementations_[index].reset(new strand_impl);
> impl = implementations_[index].get();
>}
>
>bool strand_service::running_in_this_thread(
> const implementation_type& impl) const
>{
> return call_stack<strand_impl>::contains(impl) != 0;
>}
>
>bool strand_service::do_dispatch(implementation_type& impl, operation* op)
>{
>
>
> bool can_dispatch = io_context_.can_dispatch();
> impl->mutex_.lock();
> if (can_dispatch && !impl->locked_)
> {
>
> impl->locked_ = true;
> impl->mutex_.unlock();
> return true;
> }
>
> if (impl->locked_)
> {
>
> impl->waiting_queue_.push(op);
> impl->mutex_.unlock();
> }
> else
> {
>
>
> impl->locked_ = true;
> impl->mutex_.unlock();
> impl->ready_queue_.push(op);
> io_context_.post_immediate_completion(impl, false);
> }
>
> return false;
>}
>
>void strand_service::do_post(implementation_type& impl,
> operation* op, bool is_continuation)
>{
> impl->mutex_.lock();
> if (impl->locked_)
> {
>
> impl->waiting_queue_.push(op);
> impl->mutex_.unlock();
> }
> else
> {
>
>
> impl->locked_ = true;
> impl->mutex_.unlock();
> impl->ready_queue_.push(op);
> io_context_.post_immediate_completion(impl, is_continuation);
> }
>}
>
>void strand_service::do_complete(void* owner, operation* base,
> const boost::system::error_code& ec, std::size_t )
>{
> if (owner)
> {
> strand_impl* impl = static_cast<strand_impl*>(base);
>
>
> call_stack<strand_impl>::context ctx(impl);
>
>
> on_do_complete_exit on_exit;
> on_exit.owner_ = static_cast<io_context_impl*>(owner);
> on_exit.impl_ = impl;
>
>
>
> while (operation* o = impl->ready_queue_.front())
> {
> impl->ready_queue_.pop();
> o->complete(owner, ec, 0);
> }
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 178 "/usr/include/boost/asio/detail/impl/strand_service.ipp" 2 3 4
># 142 "/usr/include/boost/asio/detail/strand_service.hpp" 2 3 4
># 25 "/usr/include/boost/asio/io_context_strand.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/io_context_strand.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 89 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
>class io_context::strand
>{
>public:
>
>
>
>
>
>
>
> explicit strand(boost::asio::io_context& io_context)
> : service_(boost::asio::use_service<
> boost::asio::detail::strand_service>(io_context))
> {
> service_.construct(impl_);
> }
># 113 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> ~strand()
> {
> }
># 127 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return service_.get_io_context();
> }
># 141 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return service_.get_io_context();
> }
>
>
>
> boost::asio::io_context& context() const noexcept
> {
> return service_.get_io_context();
> }
>
>
>
>
>
> void on_work_started() const noexcept
> {
> context().get_executor().on_work_started();
> }
>
>
>
>
>
> void on_work_finished() const noexcept
> {
> context().get_executor().on_work_finished();
> }
># 186 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> template <typename Function, typename Allocator>
> void dispatch(Function&& f, const Allocator& a) const
> {
> typename decay<Function>::type tmp(static_cast<Function&&>(f));
> service_.dispatch(impl_, tmp);
> (void)a;
> }
># 215 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void ()>::return_type
> dispatch(CompletionHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<CompletionHandler, void ()> init(handler);
>
> service_.dispatch(impl_, init.completion_handler);
>
> return init.result.get();
> }
># 244 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> template <typename Function, typename Allocator>
> void post(Function&& f, const Allocator& a) const
> {
> typename decay<Function>::type tmp(static_cast<Function&&>(f));
> service_.post(impl_, tmp);
> (void)a;
> }
># 269 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> template <typename CompletionHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void ()>::return_type
> post(CompletionHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<CompletionHandler>::type, void()>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::zero_arg_copyable_handler_test( boost::asio::detail::clvref< asio_true_handler_type>(), 0)) == 1, "CompletionHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::clvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()(), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<CompletionHandler, void ()> init(handler);
>
> service_.post(impl_, init.completion_handler);
>
> return init.result.get();
> }
># 298 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> template <typename Function, typename Allocator>
> void defer(Function&& f, const Allocator& a) const
> {
> typename decay<Function>::type tmp(static_cast<Function&&>(f));
> service_.post(impl_, tmp);
> (void)a;
> }
># 328 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> template <typename Handler>
>
>
>
> detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
>
> wrap(Handler handler)
> {
> return detail::wrapped_handler<io_context::strand, Handler,
> detail::is_continuation_if_running>(*this, handler);
> }
># 347 "/usr/include/boost/asio/io_context_strand.hpp" 3 4
> bool running_in_this_thread() const noexcept
> {
> return service_.running_in_this_thread(impl_);
> }
>
>
>
>
>
>
> friend bool operator==(const strand& a, const strand& b) noexcept
> {
> return a.impl_ == b.impl_;
> }
>
>
>
>
>
>
> friend bool operator!=(const strand& a, const strand& b) noexcept
> {
> return a.impl_ != b.impl_;
> }
>
>private:
> boost::asio::detail::strand_service& service_;
> mutable boost::asio::detail::strand_service::implementation_type impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 381 "/usr/include/boost/asio/io_context_strand.hpp" 2 3 4
># 69 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/io_service.hpp" 1 3 4
># 20 "/usr/include/boost/asio/io_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/io_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>typedef io_context io_service;
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 34 "/usr/include/boost/asio/io_service.hpp" 2 3 4
># 70 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/io_service_strand.hpp" 1 3 4
># 71 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/address.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ip/address.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/address_v4.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/array.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/array.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>using std::array;
>
>
>
>
>}
>}
>}
># 21 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/winsock_init.hpp" 1 3 4
># 25 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 46 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
>class address_v4
>{
>public:
>
> typedef uint_least32_t uint_type;
># 60 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
> typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
>
>
>
> address_v4()
> {
> addr_.s_addr = 0;
> }
>
>
> inline explicit address_v4(const bytes_type& bytes);
>
>
> inline explicit address_v4(uint_type addr);
>
>
> address_v4(const address_v4& other)
> : addr_(other.addr_)
> {
> }
>
>
>
> address_v4(address_v4&& other)
> : addr_(other.addr_)
> {
> }
>
>
>
> address_v4& operator=(const address_v4& other)
> {
> addr_ = other.addr_;
> return *this;
> }
>
>
>
> address_v4& operator=(address_v4&& other)
> {
> addr_ = other.addr_;
> return *this;
> }
>
>
>
> inline bytes_type to_bytes() const;
>
>
> inline uint_type to_uint() const;
>
>
>
> inline unsigned long to_ulong() const;
>
>
>
> inline std::string to_string() const;
>
>
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
>
> static address_v4 from_string(const char* str);
>
>
>
> static address_v4 from_string(
> const char* str, boost::system::error_code& ec);
>
>
>
> static address_v4 from_string(const std::string& str);
>
>
>
> static address_v4 from_string(
> const std::string& str, boost::system::error_code& ec);
>
>
>
> inline bool is_loopback() const;
>
>
> inline bool is_unspecified() const;
>
>
>
>
> inline bool is_class_a() const;
>
>
>
> inline bool is_class_b() const;
>
>
>
> inline bool is_class_c() const;
>
>
>
> inline bool is_multicast() const;
>
>
> friend bool operator==(const address_v4& a1, const address_v4& a2)
> {
> return a1.addr_.s_addr == a2.addr_.s_addr;
> }
>
>
> friend bool operator!=(const address_v4& a1, const address_v4& a2)
> {
> return a1.addr_.s_addr != a2.addr_.s_addr;
> }
>
>
> friend bool operator<(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_uint() < a2.to_uint();
> }
>
>
> friend bool operator>(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_uint() > a2.to_uint();
> }
>
>
> friend bool operator<=(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_uint() <= a2.to_uint();
> }
>
>
> friend bool operator>=(const address_v4& a1, const address_v4& a2)
> {
> return a1.to_uint() >= a2.to_uint();
> }
>
>
> static address_v4 any()
> {
> return address_v4();
> }
>
>
> static address_v4 loopback()
> {
> return address_v4(0x7F000001);
> }
>
>
> static address_v4 broadcast()
> {
> return address_v4(0xFFFFFFFF);
> }
>
>
>
>
>
> inline static address_v4 broadcast(
> const address_v4& addr, const address_v4& mask);
>
>
>
> inline static address_v4 netmask(const address_v4& addr);
>
>
>private:
>
> boost::asio::detail::in4_addr_type addr_;
>};
>
>
>
>
>
>inline address_v4 make_address_v4(const address_v4::bytes_type& bytes)
>{
> return address_v4(bytes);
>}
>
>
>
>
>
>inline address_v4 make_address_v4(address_v4::uint_type addr)
>{
> return address_v4(addr);
>}
>
>
>
>
>
>inline address_v4 make_address_v4(const char* str);
>
>
>
>
>
>inline address_v4 make_address_v4(
> const char* str, boost::system::error_code& ec);
>
>
>
>
>
>inline address_v4 make_address_v4(const std::string& str);
>
>
>
>
>
>inline address_v4 make_address_v4(
> const std::string& str, boost::system::error_code& ec);
># 288 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
>inline address_v4 make_address_v4(string_view str);
>
>
>
>
>
>inline address_v4 make_address_v4(
> string_view str, boost::system::error_code& ec);
># 314 "/usr/include/boost/asio/ip/address_v4.hpp" 3 4
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 325 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>
>inline address_v4 address_v4::from_string(const char* str)
>{
> return boost::asio::ip::make_address_v4(str);
>}
>
>inline address_v4 address_v4::from_string(
> const char* str, boost::system::error_code& ec)
>{
> return boost::asio::ip::make_address_v4(str, ec);
>}
>
>inline address_v4 address_v4::from_string(const std::string& str)
>{
> return boost::asio::ip::make_address_v4(str);
>}
>
>inline address_v4 address_v4::from_string(
> const std::string& str, boost::system::error_code& ec)
>{
> return boost::asio::ip::make_address_v4(str, ec);
>}
>
>
>
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
>{
> return os << addr.to_string().c_str();
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 66 "/usr/include/boost/asio/ip/impl/address_v4.hpp" 2 3 4
># 327 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 3 4
># 1 "/usr/include/c++/8/climits" 1 3 4
># 39 "/usr/include/c++/8/climits" 3 4
> 
># 40 "/usr/include/c++/8/climits" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 1 3 4
># 43 "/usr/include/c++/8/climits" 2 3
># 20 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/address_v4.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>address_v4::address_v4(const address_v4::bytes_type& bytes)
>{
># 45 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 3 4
> using namespace std;
> memcpy(&addr_.s_addr, bytes.data(), 4);
>}
>
>address_v4::address_v4(address_v4::uint_type addr)
>{
> if ((std::numeric_limits<uint_type>::max)() > 0xFFFFFFFF)
> {
> std::out_of_range ex("address_v4 from unsigned integer");
> boost::asio::detail::throw_exception(ex);
> }
>
> addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(
> static_cast<boost::asio::detail::u_long_type>(addr));
>}
>
>address_v4::bytes_type address_v4::to_bytes() const
>{
> using namespace std;
> bytes_type bytes;
>
> memcpy(bytes.data(), &addr_.s_addr, 4);
>
>
>
> return bytes;
>}
>
>address_v4::uint_type address_v4::to_uint() const
>{
> return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
>}
>
>
>unsigned long address_v4::to_ulong() const
>{
> return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
>}
>
>
>std::string address_v4::to_string() const
>{
> boost::system::error_code ec;
> char addr_str[boost::asio::detail::max_addr_v4_str_len];
> const char* addr =
> boost::asio::detail::socket_ops::inet_ntop(
> 2, &addr_, addr_str,
> boost::asio::detail::max_addr_v4_str_len, 0, ec);
> if (addr == 0)
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>
>std::string address_v4::to_string(boost::system::error_code& ec) const
>{
> char addr_str[boost::asio::detail::max_addr_v4_str_len];
> const char* addr =
> boost::asio::detail::socket_ops::inet_ntop(
> 2, &addr_, addr_str,
> boost::asio::detail::max_addr_v4_str_len, 0, ec);
> if (addr == 0)
> return std::string();
> return addr;
>}
>
>
>bool address_v4::is_loopback() const
>{
> return (to_uint() & 0xFF000000) == 0x7F000000;
>}
>
>bool address_v4::is_unspecified() const
>{
> return to_uint() == 0;
>}
>
>
>bool address_v4::is_class_a() const
>{
> return (to_uint() & 0x80000000) == 0;
>}
>
>bool address_v4::is_class_b() const
>{
> return (to_uint() & 0xC0000000) == 0x80000000;
>}
>
>bool address_v4::is_class_c() const
>{
> return (to_uint() & 0xE0000000) == 0xC0000000;
>}
>
>
>bool address_v4::is_multicast() const
>{
> return (to_uint() & 0xF0000000) == 0xE0000000;
>}
>
>
>address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
>{
> return address_v4(addr.to_uint() | (mask.to_uint() ^ 0xFFFFFFFF));
>}
>
>address_v4 address_v4::netmask(const address_v4& addr)
>{
> if (addr.is_class_a())
> return address_v4(0xFF000000);
> if (addr.is_class_b())
> return address_v4(0xFFFF0000);
> if (addr.is_class_c())
> return address_v4(0xFFFFFF00);
> return address_v4(0xFFFFFFFF);
>}
>
>
>address_v4 make_address_v4(const char* str)
>{
> boost::system::error_code ec;
> address_v4 addr = make_address_v4(str, ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>address_v4 make_address_v4(
> const char* str, boost::system::error_code& ec)
>{
> address_v4::bytes_type bytes;
> if (boost::asio::detail::socket_ops::inet_pton(
> 2, str, &bytes, 0, ec) <= 0)
> return address_v4();
> return address_v4(bytes);
>}
>
>address_v4 make_address_v4(const std::string& str)
>{
> return make_address_v4(str.c_str());
>}
>
>address_v4 make_address_v4(
> const std::string& str, boost::system::error_code& ec)
>{
> return make_address_v4(str.c_str(), ec);
>}
>
>
>
>address_v4 make_address_v4(string_view str)
>{
> return make_address_v4(static_cast<std::string>(str));
>}
>
>address_v4 make_address_v4(string_view str,
> boost::system::error_code& ec)
>{
> return make_address_v4(static_cast<std::string>(str), ec);
>}
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 211 "/usr/include/boost/asio/ip/impl/address_v4.ipp" 2 3 4
># 329 "/usr/include/boost/asio/ip/address_v4.hpp" 2 3 4
># 25 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/address_v6.hpp" 1 3 4
># 31 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename> class basic_address_iterator;
># 48 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
>class address_v6
>{
>public:
># 59 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
> typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
>
>
>
> inline address_v6();
>
>
> inline explicit address_v6(const bytes_type& bytes,
> unsigned long scope_id = 0);
>
>
> inline address_v6(const address_v6& other);
>
>
>
> inline address_v6(address_v6&& other);
>
>
>
> inline address_v6& operator=(const address_v6& other);
>
>
>
> inline address_v6& operator=(address_v6&& other);
>
>
>
>
>
>
> unsigned long scope_id() const
> {
> return scope_id_;
> }
>
>
>
>
>
> void scope_id(unsigned long id)
> {
> scope_id_ = id;
> }
>
>
> inline bytes_type to_bytes() const;
>
>
> inline std::string to_string() const;
>
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
>
> static address_v6 from_string(const char* str);
>
>
>
> static address_v6 from_string(
> const char* str, boost::system::error_code& ec);
>
>
>
> static address_v6 from_string(const std::string& str);
>
>
>
> static address_v6 from_string(
> const std::string& str, boost::system::error_code& ec);
>
>
>
> inline address_v4 to_v4() const;
>
>
>
> inline bool is_loopback() const;
>
>
> inline bool is_unspecified() const;
>
>
> inline bool is_link_local() const;
>
>
> inline bool is_site_local() const;
>
>
> inline bool is_v4_mapped() const;
>
>
>
>
> inline bool is_v4_compatible() const;
>
>
>
> inline bool is_multicast() const;
>
>
> inline bool is_multicast_global() const;
>
>
> inline bool is_multicast_link_local() const;
>
>
> inline bool is_multicast_node_local() const;
>
>
> inline bool is_multicast_org_local() const;
>
>
> inline bool is_multicast_site_local() const;
>
>
> inline friend bool operator==(
> const address_v6& a1, const address_v6& a2);
>
>
> friend bool operator!=(const address_v6& a1, const address_v6& a2)
> {
> return !(a1 == a2);
> }
>
>
> inline friend bool operator<(
> const address_v6& a1, const address_v6& a2);
>
>
> friend bool operator>(const address_v6& a1, const address_v6& a2)
> {
> return a2 < a1;
> }
>
>
> friend bool operator<=(const address_v6& a1, const address_v6& a2)
> {
> return !(a2 < a1);
> }
>
>
> friend bool operator>=(const address_v6& a1, const address_v6& a2)
> {
> return !(a1 < a2);
> }
>
>
> static address_v6 any()
> {
> return address_v6();
> }
>
>
> inline static address_v6 loopback();
>
>
>
> inline static address_v6 v4_mapped(const address_v4& addr);
>
>
> inline static address_v6 v4_compatible(const address_v4& addr);
>
>
>private:
> friend class basic_address_iterator<address_v6>;
>
>
> boost::asio::detail::in6_addr_type addr_;
>
>
> unsigned long scope_id_;
>};
>
>
>
>
>
>inline address_v6 make_address_v6(const address_v6::bytes_type& bytes,
> unsigned long scope_id = 0)
>{
> return address_v6(bytes, scope_id);
>}
>
>
>
>
>
>inline address_v6 make_address_v6(const char* str);
>
>
>
>
>
>inline address_v6 make_address_v6(
> const char* str, boost::system::error_code& ec);
>
>
>
>
>
>inline address_v6 make_address_v6(const std::string& str);
>
>
>
>
>
>inline address_v6 make_address_v6(
> const std::string& str, boost::system::error_code& ec);
># 277 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
>inline address_v6 make_address_v6(string_view str);
>
>
>
>
>
>inline address_v6 make_address_v6(
> string_view str, boost::system::error_code& ec);
>
>
>
>
>
>
>enum v4_mapped_t { v4_mapped };
>
>
>
>
>
>inline address_v4 make_address_v4(
> v4_mapped_t, const address_v6& v6_addr);
>
>
>
>
>
>inline address_v6 make_address_v6(
> v4_mapped_t, const address_v4& v4_addr);
># 321 "/usr/include/boost/asio/ip/address_v6.hpp" 3 4
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 332 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>
>inline address_v6 address_v6::from_string(const char* str)
>{
> return boost::asio::ip::make_address_v6(str);
>}
>
>inline address_v6 address_v6::from_string(
> const char* str, boost::system::error_code& ec)
>{
> return boost::asio::ip::make_address_v6(str, ec);
>}
>
>inline address_v6 address_v6::from_string(const std::string& str)
>{
> return boost::asio::ip::make_address_v6(str);
>}
>
>inline address_v6 address_v6::from_string(
> const std::string& str, boost::system::error_code& ec)
>{
> return boost::asio::ip::make_address_v6(str, ec);
>}
>
>
>
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
>{
> return os << addr.to_string().c_str();
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 66 "/usr/include/boost/asio/ip/impl/address_v6.hpp" 2 3 4
># 334 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 20 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/address_v6.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
># 1 "/usr/include/boost/asio/ip/bad_address_cast.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/bad_address_cast.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ip/bad_address_cast.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>class bad_address_cast : public std::bad_cast
>{
>public:
>
> bad_address_cast() {}
>
>
> virtual ~bad_address_cast() noexcept {}
>
>
> virtual const char* what() const noexcept
> {
> return "bad address cast";
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 49 "/usr/include/boost/asio/ip/bad_address_cast.hpp" 2 3 4
># 28 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>address_v6::address_v6()
> : addr_(),
> scope_id_(0)
>{
>}
>
>address_v6::address_v6(const address_v6::bytes_type& bytes,
> unsigned long scope)
> : scope_id_(scope)
>{
># 56 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 3 4
> using namespace std;
> memcpy(addr_.__in6_u.__u6_addr8, bytes.data(), 16);
>}
>
>address_v6::address_v6(const address_v6& other)
> : addr_(other.addr_),
> scope_id_(other.scope_id_)
>{
>}
>
>
>address_v6::address_v6(address_v6&& other)
> : addr_(other.addr_),
> scope_id_(other.scope_id_)
>{
>}
>
>
>address_v6& address_v6::operator=(const address_v6& other)
>{
> addr_ = other.addr_;
> scope_id_ = other.scope_id_;
> return *this;
>}
>
>
>address_v6& address_v6::operator=(address_v6&& other)
>{
> addr_ = other.addr_;
> scope_id_ = other.scope_id_;
> return *this;
>}
>
>
>address_v6::bytes_type address_v6::to_bytes() const
>{
> using namespace std;
> bytes_type bytes;
>
> memcpy(bytes.data(), addr_.__in6_u.__u6_addr8, 16);
>
>
>
> return bytes;
>}
>
>std::string address_v6::to_string() const
>{
> boost::system::error_code ec;
> char addr_str[boost::asio::detail::max_addr_v6_str_len];
> const char* addr =
> boost::asio::detail::socket_ops::inet_ntop(
> 10, &addr_, addr_str,
> boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
> if (addr == 0)
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>
>std::string address_v6::to_string(boost::system::error_code& ec) const
>{
> char addr_str[boost::asio::detail::max_addr_v6_str_len];
> const char* addr =
> boost::asio::detail::socket_ops::inet_ntop(
> 10, &addr_, addr_str,
> boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
> if (addr == 0)
> return std::string();
> return addr;
>}
>
>address_v4 address_v6::to_v4() const
>{
> if (!is_v4_mapped() && !is_v4_compatible())
> {
> bad_address_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
>
> address_v4::bytes_type v4_bytes = { { addr_.__in6_u.__u6_addr8[12],
> addr_.__in6_u.__u6_addr8[13], addr_.__in6_u.__u6_addr8[14], addr_.__in6_u.__u6_addr8[15] } };
> return address_v4(v4_bytes);
>}
>
>
>bool address_v6::is_loopback() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
> && (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
> && (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 1));
>}
>
>bool address_v6::is_unspecified() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
> && (addr_.__in6_u.__u6_addr8[12] == 0) && (addr_.__in6_u.__u6_addr8[13] == 0)
> && (addr_.__in6_u.__u6_addr8[14] == 0) && (addr_.__in6_u.__u6_addr8[15] == 0));
>}
>
>bool address_v6::is_link_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0x80));
>}
>
>bool address_v6::is_site_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xfe) && ((addr_.__in6_u.__u6_addr8[1] & 0xc0) == 0xc0));
>}
>
>bool address_v6::is_v4_mapped() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0xff) && (addr_.__in6_u.__u6_addr8[11] == 0xff));
>}
>
>
>bool address_v6::is_v4_compatible() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0) && (addr_.__in6_u.__u6_addr8[1] == 0)
> && (addr_.__in6_u.__u6_addr8[2] == 0) && (addr_.__in6_u.__u6_addr8[3] == 0)
> && (addr_.__in6_u.__u6_addr8[4] == 0) && (addr_.__in6_u.__u6_addr8[5] == 0)
> && (addr_.__in6_u.__u6_addr8[6] == 0) && (addr_.__in6_u.__u6_addr8[7] == 0)
> && (addr_.__in6_u.__u6_addr8[8] == 0) && (addr_.__in6_u.__u6_addr8[9] == 0)
> && (addr_.__in6_u.__u6_addr8[10] == 0) && (addr_.__in6_u.__u6_addr8[11] == 0)
> && !((addr_.__in6_u.__u6_addr8[12] == 0)
> && (addr_.__in6_u.__u6_addr8[13] == 0)
> && (addr_.__in6_u.__u6_addr8[14] == 0)
> && ((addr_.__in6_u.__u6_addr8[15] == 0) || (addr_.__in6_u.__u6_addr8[15] == 1))));
>}
>
>
>bool address_v6::is_multicast() const
>{
> return (addr_.__in6_u.__u6_addr8[0] == 0xff);
>}
>
>bool address_v6::is_multicast_global() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x0e));
>}
>
>bool address_v6::is_multicast_link_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x02));
>}
>
>bool address_v6::is_multicast_node_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x01));
>}
>
>bool address_v6::is_multicast_org_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x08));
>}
>
>bool address_v6::is_multicast_site_local() const
>{
> return ((addr_.__in6_u.__u6_addr8[0] == 0xff) && ((addr_.__in6_u.__u6_addr8[1] & 0x0f) == 0x05));
>}
>
>bool operator==(const address_v6& a1, const address_v6& a2)
>{
> using namespace std;
> return memcmp(&a1.addr_, &a2.addr_,
> sizeof(boost::asio::detail::in6_addr_type)) == 0
> && a1.scope_id_ == a2.scope_id_;
>}
>
>bool operator<(const address_v6& a1, const address_v6& a2)
>{
> using namespace std;
> int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
> sizeof(boost::asio::detail::in6_addr_type));
> if (memcmp_result < 0)
> return true;
> if (memcmp_result > 0)
> return false;
> return a1.scope_id_ < a2.scope_id_;
>}
>
>address_v6 address_v6::loopback()
>{
> address_v6 tmp;
> tmp.addr_.__in6_u.__u6_addr8[15] = 1;
> return tmp;
>}
>
>
>address_v6 address_v6::v4_mapped(const address_v4& addr)
>{
> address_v4::bytes_type v4_bytes = addr.to_bytes();
> bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF,
> v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
> return address_v6(v6_bytes);
>}
>
>address_v6 address_v6::v4_compatible(const address_v4& addr)
>{
> address_v4::bytes_type v4_bytes = addr.to_bytes();
> bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
> return address_v6(v6_bytes);
>}
>
>
>address_v6 make_address_v6(const char* str)
>{
> boost::system::error_code ec;
> address_v6 addr = make_address_v6(str, ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>address_v6 make_address_v6(
> const char* str, boost::system::error_code& ec)
>{
> address_v6::bytes_type bytes;
> unsigned long scope_id = 0;
> if (boost::asio::detail::socket_ops::inet_pton(
> 10, str, &bytes[0], &scope_id, ec) <= 0)
> return address_v6();
> return address_v6(bytes, scope_id);
>}
>
>address_v6 make_address_v6(const std::string& str)
>{
> return make_address_v6(str.c_str());
>}
>
>address_v6 make_address_v6(
> const std::string& str, boost::system::error_code& ec)
>{
> return make_address_v6(str.c_str(), ec);
>}
>
>
>
>address_v6 make_address_v6(string_view str)
>{
> return make_address_v6(static_cast<std::string>(str));
>}
>
>address_v6 make_address_v6(string_view str,
> boost::system::error_code& ec)
>{
> return make_address_v6(static_cast<std::string>(str), ec);
>}
>
>
>
>address_v4 make_address_v4(
> v4_mapped_t, const address_v6& v6_addr)
>{
> if (!v6_addr.is_v4_mapped())
> {
> bad_address_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
>
> address_v6::bytes_type v6_bytes = v6_addr.to_bytes();
> address_v4::bytes_type v4_bytes = { { v6_bytes[12],
> v6_bytes[13], v6_bytes[14], v6_bytes[15] } };
> return address_v4(v4_bytes);
>}
>
>address_v6 make_address_v6(
> v4_mapped_t, const address_v4& v4_addr)
>{
> address_v4::bytes_type v4_bytes = v4_addr.to_bytes();
> address_v6::bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
> 0xFF, 0xFF, v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
> return address_v6(v6_bytes);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 351 "/usr/include/boost/asio/ip/impl/address_v6.ipp" 2 3 4
># 336 "/usr/include/boost/asio/ip/address_v6.hpp" 2 3 4
># 26 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 33 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 47 "/usr/include/boost/asio/ip/address.hpp" 3 4
>class address
>{
>public:
>
> inline address();
>
>
> inline address(const boost::asio::ip::address_v4& ipv4_address);
>
>
> inline address(const boost::asio::ip::address_v6& ipv6_address);
>
>
> inline address(const address& other);
>
>
>
> inline address(address&& other);
>
>
>
> inline address& operator=(const address& other);
>
>
>
> inline address& operator=(address&& other);
>
>
>
> inline address& operator=(
> const boost::asio::ip::address_v4& ipv4_address);
>
>
> inline address& operator=(
> const boost::asio::ip::address_v6& ipv6_address);
>
>
> bool is_v4() const
> {
> return type_ == ipv4;
> }
>
>
> bool is_v6() const
> {
> return type_ == ipv6;
> }
>
>
> inline boost::asio::ip::address_v4 to_v4() const;
>
>
> inline boost::asio::ip::address_v6 to_v6() const;
>
>
> inline std::string to_string() const;
>
>
>
> inline std::string to_string(boost::system::error_code& ec) const;
>
>
>
>
> static address from_string(const char* str);
>
>
>
>
> static address from_string(const char* str, boost::system::error_code& ec);
>
>
>
>
> static address from_string(const std::string& str);
>
>
>
>
> static address from_string(
> const std::string& str, boost::system::error_code& ec);
>
>
>
> inline bool is_loopback() const;
>
>
> inline bool is_unspecified() const;
>
>
> inline bool is_multicast() const;
>
>
> inline friend bool operator==(const address& a1, const address& a2);
>
>
> friend bool operator!=(const address& a1, const address& a2)
> {
> return !(a1 == a2);
> }
>
>
> inline friend bool operator<(const address& a1, const address& a2);
>
>
> friend bool operator>(const address& a1, const address& a2)
> {
> return a2 < a1;
> }
>
>
> friend bool operator<=(const address& a1, const address& a2)
> {
> return !(a2 < a1);
> }
>
>
> friend bool operator>=(const address& a1, const address& a2)
> {
> return !(a1 < a2);
> }
>
>private:
>
> enum { ipv4, ipv6 } type_;
>
>
> boost::asio::ip::address_v4 ipv4_address_;
>
>
> boost::asio::ip::address_v6 ipv6_address_;
>};
>
>
>
>
>
>
>inline address make_address(const char* str);
>
>
>
>
>
>
>inline address make_address(
> const char* str, boost::system::error_code& ec);
>
>
>
>
>
>
>inline address make_address(const std::string& str);
>
>
>
>
>
>
>inline address make_address(
> const std::string& str, boost::system::error_code& ec);
># 218 "/usr/include/boost/asio/ip/address.hpp" 3 4
>inline address make_address(string_view str);
>
>
>
>
>
>
>inline address make_address(
> string_view str, boost::system::error_code& ec);
># 245 "/usr/include/boost/asio/ip/address.hpp" 3 4
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address& addr);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 256 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/address.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/impl/address.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>
>inline address address::from_string(const char* str)
>{
> return boost::asio::ip::make_address(str);
>}
>
>inline address address::from_string(
> const char* str, boost::system::error_code& ec)
>{
> return boost::asio::ip::make_address(str, ec);
>}
>
>inline address address::from_string(const std::string& str)
>{
> return boost::asio::ip::make_address(str);
>}
>
>inline address address::from_string(
> const std::string& str, boost::system::error_code& ec)
>{
> return boost::asio::ip::make_address(str, ec);
>}
>
>
>
>template <typename Elem, typename Traits>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os, const address& addr)
>{
> return os << addr.to_string().c_str();
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 66 "/usr/include/boost/asio/ip/impl/address.hpp" 2 3 4
># 258 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/address.ipp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/address.ipp" 3 4
># 1 "/usr/include/boost/asio/ip/address.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ip/impl/address.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/ip/impl/address.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>address::address()
> : type_(ipv4),
> ipv4_address_(),
> ipv6_address_()
>{
>}
>
>address::address(const boost::asio::ip::address_v4& ipv4_address)
> : type_(ipv4),
> ipv4_address_(ipv4_address),
> ipv6_address_()
>{
>}
>
>address::address(const boost::asio::ip::address_v6& ipv6_address)
> : type_(ipv6),
> ipv4_address_(),
> ipv6_address_(ipv6_address)
>{
>}
>
>address::address(const address& other)
> : type_(other.type_),
> ipv4_address_(other.ipv4_address_),
> ipv6_address_(other.ipv6_address_)
>{
>}
>
>
>address::address(address&& other)
> : type_(other.type_),
> ipv4_address_(other.ipv4_address_),
> ipv6_address_(other.ipv6_address_)
>{
>}
>
>
>address& address::operator=(const address& other)
>{
> type_ = other.type_;
> ipv4_address_ = other.ipv4_address_;
> ipv6_address_ = other.ipv6_address_;
> return *this;
>}
>
>
>address& address::operator=(address&& other)
>{
> type_ = other.type_;
> ipv4_address_ = other.ipv4_address_;
> ipv6_address_ = other.ipv6_address_;
> return *this;
>}
>
>
>address& address::operator=(const boost::asio::ip::address_v4& ipv4_address)
>{
> type_ = ipv4;
> ipv4_address_ = ipv4_address;
> ipv6_address_ = boost::asio::ip::address_v6();
> return *this;
>}
>
>address& address::operator=(const boost::asio::ip::address_v6& ipv6_address)
>{
> type_ = ipv6;
> ipv4_address_ = boost::asio::ip::address_v4();
> ipv6_address_ = ipv6_address;
> return *this;
>}
>
>address make_address(const char* str)
>{
> boost::system::error_code ec;
> address addr = make_address(str, ec);
> boost::asio::detail::throw_error(ec);
> return addr;
>}
>
>address make_address(const char* str, boost::system::error_code& ec)
>{
> boost::asio::ip::address_v6 ipv6_address =
> boost::asio::ip::make_address_v6(str, ec);
> if (!ec)
> return address(ipv6_address);
>
> boost::asio::ip::address_v4 ipv4_address =
> boost::asio::ip::make_address_v4(str, ec);
> if (!ec)
> return address(ipv4_address);
>
> return address();
>}
>
>address make_address(const std::string& str)
>{
> return make_address(str.c_str());
>}
>
>address make_address(const std::string& str,
> boost::system::error_code& ec)
>{
> return make_address(str.c_str(), ec);
>}
>
>
>
>address make_address(string_view str)
>{
> return make_address(static_cast<std::string>(str));
>}
>
>address make_address(string_view str,
> boost::system::error_code& ec)
>{
> return make_address(static_cast<std::string>(str), ec);
>}
>
>
>
>boost::asio::ip::address_v4 address::to_v4() const
>{
> if (type_ != ipv4)
> {
> bad_address_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> return ipv4_address_;
>}
>
>boost::asio::ip::address_v6 address::to_v6() const
>{
> if (type_ != ipv6)
> {
> bad_address_cast ex;
> boost::asio::detail::throw_exception(ex);
> }
> return ipv6_address_;
>}
>
>std::string address::to_string() const
>{
> if (type_ == ipv6)
> return ipv6_address_.to_string();
> return ipv4_address_.to_string();
>}
>
>
>std::string address::to_string(boost::system::error_code& ec) const
>{
> if (type_ == ipv6)
> return ipv6_address_.to_string(ec);
> return ipv4_address_.to_string(ec);
>}
>
>
>bool address::is_loopback() const
>{
> return (type_ == ipv4)
> ? ipv4_address_.is_loopback()
> : ipv6_address_.is_loopback();
>}
>
>bool address::is_unspecified() const
>{
> return (type_ == ipv4)
> ? ipv4_address_.is_unspecified()
> : ipv6_address_.is_unspecified();
>}
>
>bool address::is_multicast() const
>{
> return (type_ == ipv4)
> ? ipv4_address_.is_multicast()
> : ipv6_address_.is_multicast();
>}
>
>bool operator==(const address& a1, const address& a2)
>{
> if (a1.type_ != a2.type_)
> return false;
> if (a1.type_ == address::ipv6)
> return a1.ipv6_address_ == a2.ipv6_address_;
> return a1.ipv4_address_ == a2.ipv4_address_;
>}
>
>bool operator<(const address& a1, const address& a2)
>{
> if (a1.type_ < a2.type_)
> return true;
> if (a1.type_ > a2.type_)
> return false;
> if (a1.type_ == address::ipv6)
> return a1.ipv6_address_ < a2.ipv6_address_;
> return a1.ipv4_address_ < a2.ipv4_address_;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 235 "/usr/include/boost/asio/ip/impl/address.ipp" 2 3 4
># 260 "/usr/include/boost/asio/ip/address.hpp" 2 3 4
># 72 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/address_v4_iterator.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/address_v4_iterator.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ip/address_v4_iterator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename> class basic_address_iterator;
># 38 "/usr/include/boost/asio/ip/address_v4_iterator.hpp" 3 4
>template <> class basic_address_iterator<address_v4>
>{
>public:
>
> typedef address_v4 value_type;
>
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef const address_v4* pointer;
>
>
> typedef const address_v4& reference;
>
>
> typedef std::input_iterator_tag iterator_category;
>
>
> basic_address_iterator(const address_v4& addr) noexcept
> : address_(addr)
> {
> }
>
>
> basic_address_iterator(
> const basic_address_iterator& other) noexcept
> : address_(other.address_)
> {
> }
>
>
>
> basic_address_iterator(basic_address_iterator&& other) noexcept
> : address_(static_cast<address_v4&&>(other.address_))
> {
> }
>
>
>
> basic_address_iterator& operator=(
> const basic_address_iterator& other) noexcept
> {
> address_ = other.address_;
> return *this;
> }
>
>
>
> basic_address_iterator& operator=(
> basic_address_iterator&& other) noexcept
> {
> address_ = static_cast<address_v4&&>(other.address_);
> return *this;
> }
>
>
>
> const address_v4& operator*() const noexcept
> {
> return address_;
> }
>
>
> const address_v4* operator->() const noexcept
> {
> return &address_;
> }
>
>
> basic_address_iterator& operator++() noexcept
> {
> address_ = address_v4((address_.to_uint() + 1) & 0xFFFFFFFF);
> return *this;
> }
>
>
> basic_address_iterator operator++(int) noexcept
> {
> basic_address_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> basic_address_iterator& operator--() noexcept
> {
> address_ = address_v4((address_.to_uint() - 1) & 0xFFFFFFFF);
> return *this;
> }
>
>
> basic_address_iterator operator--(int)
> {
> basic_address_iterator tmp(*this);
> --*this;
> return tmp;
> }
>
>
> friend bool operator==(const basic_address_iterator& a,
> const basic_address_iterator& b)
> {
> return a.address_ == b.address_;
> }
>
>
> friend bool operator!=(const basic_address_iterator& a,
> const basic_address_iterator& b)
> {
> return a.address_ != b.address_;
> }
>
>private:
> address_v4 address_;
>};
>
>
>typedef basic_address_iterator<address_v4> address_v4_iterator;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 163 "/usr/include/boost/asio/ip/address_v4_iterator.hpp" 2 3 4
># 74 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/address_v4_range.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/address_v4_range.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ip/address_v4_range.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename> class basic_address_range;
>
>
>
>
>
>
>
>template <> class basic_address_range<address_v4>
>{
>public:
>
> typedef basic_address_iterator<address_v4> iterator;
>
>
> basic_address_range() noexcept
> : begin_(address_v4()),
> end_(address_v4())
> {
> }
>
>
> explicit basic_address_range(const iterator& first,
> const iterator& last) noexcept
> : begin_(first),
> end_(last)
> {
> }
>
>
> basic_address_range(const basic_address_range& other) noexcept
> : begin_(other.begin_),
> end_(other.end_)
> {
> }
>
>
>
> basic_address_range(basic_address_range&& other) noexcept
> : begin_(static_cast<iterator&&>(other.begin_)),
> end_(static_cast<iterator&&>(other.end_))
> {
> }
>
>
>
> basic_address_range& operator=(
> const basic_address_range& other) noexcept
> {
> begin_ = other.begin_;
> end_ = other.end_;
> return *this;
> }
>
>
>
> basic_address_range& operator=(
> basic_address_range&& other) noexcept
> {
> begin_ = static_cast<iterator&&>(other.begin_);
> end_ = static_cast<iterator&&>(other.end_);
> return *this;
> }
>
>
>
> iterator begin() const noexcept
> {
> return begin_;
> }
>
>
> iterator end() const noexcept
> {
> return end_;
> }
>
>
> bool empty() const noexcept
> {
> return size() == 0;
> }
>
>
> std::size_t size() const noexcept
> {
> return end_->to_uint() - begin_->to_uint();
> }
>
>
> iterator find(const address_v4& addr) const noexcept
> {
> return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
> }
>
>private:
> iterator begin_;
> iterator end_;
>};
>
>
>typedef basic_address_range<address_v4> address_v4_range;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 135 "/usr/include/boost/asio/ip/address_v4_range.hpp" 2 3 4
># 75 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/address_v6_iterator.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/address_v6_iterator.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/address_v6_iterator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename> class basic_address_iterator;
># 39 "/usr/include/boost/asio/ip/address_v6_iterator.hpp" 3 4
>template <> class basic_address_iterator<address_v6>
>{
>public:
>
> typedef address_v6 value_type;
>
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef const address_v6* pointer;
>
>
> typedef const address_v6& reference;
>
>
> typedef std::input_iterator_tag iterator_category;
>
>
> basic_address_iterator(const address_v6& addr) noexcept
> : address_(addr)
> {
> }
>
>
> basic_address_iterator(
> const basic_address_iterator& other) noexcept
> : address_(other.address_)
> {
> }
>
>
>
> basic_address_iterator(basic_address_iterator&& other) noexcept
> : address_(static_cast<address_v6&&>(other.address_))
> {
> }
>
>
>
> basic_address_iterator& operator=(
> const basic_address_iterator& other) noexcept
> {
> address_ = other.address_;
> return *this;
> }
>
>
>
> basic_address_iterator& operator=(
> basic_address_iterator&& other) noexcept
> {
> address_ = static_cast<address_v6&&>(other.address_);
> return *this;
> }
>
>
>
> const address_v6& operator*() const noexcept
> {
> return address_;
> }
>
>
> const address_v6* operator->() const noexcept
> {
> return &address_;
> }
>
>
> basic_address_iterator& operator++() noexcept
> {
> for (int i = 15; i >= 0; --i)
> {
> if (address_.addr_.__in6_u.__u6_addr8[i] < 0xFF)
> {
> ++address_.addr_.__in6_u.__u6_addr8[i];
> break;
> }
>
> address_.addr_.__in6_u.__u6_addr8[i] = 0;
> }
>
> return *this;
> }
>
>
> basic_address_iterator operator++(int) noexcept
> {
> basic_address_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> basic_address_iterator& operator--() noexcept
> {
> for (int i = 15; i >= 0; --i)
> {
> if (address_.addr_.__in6_u.__u6_addr8[i] > 0)
> {
> --address_.addr_.__in6_u.__u6_addr8[i];
> break;
> }
>
> address_.addr_.__in6_u.__u6_addr8[i] = 0xFF;
> }
>
> return *this;
> }
>
>
> basic_address_iterator operator--(int)
> {
> basic_address_iterator tmp(*this);
> --*this;
> return tmp;
> }
>
>
> friend bool operator==(const basic_address_iterator& a,
> const basic_address_iterator& b)
> {
> return a.address_ == b.address_;
> }
>
>
> friend bool operator!=(const basic_address_iterator& a,
> const basic_address_iterator& b)
> {
> return a.address_ != b.address_;
> }
>
>private:
> address_v6 address_;
>};
>
>
>typedef basic_address_iterator<address_v6> address_v6_iterator;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 184 "/usr/include/boost/asio/ip/address_v6_iterator.hpp" 2 3 4
># 77 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/address_v6_range.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/address_v6_range.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/address_v6_range.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename> class basic_address_range;
>
>
>
>
>
>
>
>template <> class basic_address_range<address_v6>
>{
>public:
>
> typedef basic_address_iterator<address_v6> iterator;
>
>
> basic_address_range() noexcept
> : begin_(address_v6()),
> end_(address_v6())
> {
> }
>
>
> explicit basic_address_range(const iterator& first,
> const iterator& last) noexcept
> : begin_(first),
> end_(last)
> {
> }
>
>
> basic_address_range(const basic_address_range& other) noexcept
> : begin_(other.begin_),
> end_(other.end_)
> {
> }
>
>
>
> basic_address_range(basic_address_range&& other) noexcept
> : begin_(static_cast<iterator&&>(other.begin_)),
> end_(static_cast<iterator&&>(other.end_))
> {
> }
>
>
>
> basic_address_range& operator=(
> const basic_address_range& other) noexcept
> {
> begin_ = other.begin_;
> end_ = other.end_;
> return *this;
> }
>
>
>
> basic_address_range& operator=(
> basic_address_range&& other) noexcept
> {
> begin_ = static_cast<iterator&&>(other.begin_);
> end_ = static_cast<iterator&&>(other.end_);
> return *this;
> }
>
>
>
> iterator begin() const noexcept
> {
> return begin_;
> }
>
>
> iterator end() const noexcept
> {
> return end_;
> }
>
>
> bool empty() const noexcept
> {
> return begin_ == end_;
> }
>
>
> iterator find(const address_v6& addr) const noexcept
> {
> return addr >= *begin_ && addr < *end_ ? iterator(addr) : end_;
> }
>
>private:
> iterator begin_;
> iterator end_;
>};
>
>
>typedef basic_address_range<address_v6> address_v6_range;
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 130 "/usr/include/boost/asio/ip/address_v6_range.hpp" 2 3 4
># 78 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 1 3 4
># 25 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace detail {
>
>
>class endpoint
>{
>public:
>
> inline endpoint();
>
>
> inline endpoint(int family, unsigned short port_num);
>
>
> inline endpoint(const boost::asio::ip::address& addr,
> unsigned short port_num);
>
>
> endpoint(const endpoint& other)
> : data_(other.data_)
> {
> }
>
>
> endpoint& operator=(const endpoint& other)
> {
> data_ = other.data_;
> return *this;
> }
>
>
> boost::asio::detail::socket_addr_type* data()
> {
> return &data_.base;
> }
>
>
> const boost::asio::detail::socket_addr_type* data() const
> {
> return &data_.base;
> }
>
>
> std::size_t size() const
> {
> if (is_v4())
> return sizeof(boost::asio::detail::sockaddr_in4_type);
> else
> return sizeof(boost::asio::detail::sockaddr_in6_type);
> }
>
>
> inline void resize(std::size_t new_size);
>
>
> std::size_t capacity() const
> {
> return sizeof(data_);
> }
>
>
> inline unsigned short port() const;
>
>
> inline void port(unsigned short port_num);
>
>
> inline boost::asio::ip::address address() const;
>
>
> inline void address(const boost::asio::ip::address& addr);
>
>
> inline friend bool operator==(
> const endpoint& e1, const endpoint& e2);
>
>
> inline friend bool operator<(
> const endpoint& e1, const endpoint& e2);
>
>
> bool is_v4() const
> {
> return data_.base.sa_family == 2;
> }
>
>
>
> inline std::string to_string() const;
>
>
>private:
>
> union data_union
> {
> boost::asio::detail::socket_addr_type base;
> boost::asio::detail::sockaddr_in4_type v4;
> boost::asio::detail::sockaddr_in6_type v6;
> } data_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 136 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 20 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace detail {
>
>endpoint::endpoint()
> : data_()
>{
> data_.v4.sin_family = 2;
> data_.v4.sin_port = 0;
> data_.v4.sin_addr.s_addr = ((in_addr_t) 0x00000000);
>}
>
>endpoint::endpoint(int family, unsigned short port_num)
> : data_()
>{
> using namespace std;
> if (family == 2)
> {
> data_.v4.sin_family = 2;
> data_.v4.sin_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v4.sin_addr.s_addr = ((in_addr_t) 0x00000000);
> }
> else
> {
> data_.v6.sin6_family = 10;
> data_.v6.sin6_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v6.sin6_flowinfo = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[0] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[1] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[2] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[3] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[4] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[5] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[6] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[7] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[8] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[9] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[10] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[11] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[12] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[13] = 0;
> data_.v6.sin6_addr.__in6_u.__u6_addr8[14] = 0; data_.v6.sin6_addr.__in6_u.__u6_addr8[15] = 0;
> data_.v6.sin6_scope_id = 0;
> }
>}
>
>endpoint::endpoint(const boost::asio::ip::address& addr,
> unsigned short port_num)
> : data_()
>{
> using namespace std;
> if (addr.is_v4())
> {
> data_.v4.sin_family = 2;
> data_.v4.sin_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v4.sin_addr.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> addr.to_v4().to_uint());
> }
> else
> {
> data_.v6.sin6_family = 10;
> data_.v6.sin6_port =
> boost::asio::detail::socket_ops::host_to_network_short(port_num);
> data_.v6.sin6_flowinfo = 0;
> boost::asio::ip::address_v6 v6_addr = addr.to_v6();
> boost::asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
> memcpy(data_.v6.sin6_addr.__in6_u.__u6_addr8, bytes.data(), 16);
> data_.v6.sin6_scope_id =
> static_cast<boost::asio::detail::u_long_type>(
> v6_addr.scope_id());
> }
>}
>
>void endpoint::resize(std::size_t new_size)
>{
> if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
>}
>
>unsigned short endpoint::port() const
>{
> if (is_v4())
> {
> return boost::asio::detail::socket_ops::network_to_host_short(
> data_.v4.sin_port);
> }
> else
> {
> return boost::asio::detail::socket_ops::network_to_host_short(
> data_.v6.sin6_port);
> }
>}
>
>void endpoint::port(unsigned short port_num)
>{
> if (is_v4())
> {
> data_.v4.sin_port
> = boost::asio::detail::socket_ops::host_to_network_short(port_num);
> }
> else
> {
> data_.v6.sin6_port
> = boost::asio::detail::socket_ops::host_to_network_short(port_num);
> }
>}
>
>boost::asio::ip::address endpoint::address() const
>{
> using namespace std;
> if (is_v4())
> {
> return boost::asio::ip::address_v4(
> boost::asio::detail::socket_ops::network_to_host_long(
> data_.v4.sin_addr.s_addr));
> }
> else
> {
> boost::asio::ip::address_v6::bytes_type bytes;
>
> memcpy(bytes.data(), data_.v6.sin6_addr.__in6_u.__u6_addr8, 16);
>
>
>
> return boost::asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
> }
>}
>
>void endpoint::address(const boost::asio::ip::address& addr)
>{
> endpoint tmp_endpoint(addr, port());
> data_ = tmp_endpoint.data_;
>}
>
>bool operator==(const endpoint& e1, const endpoint& e2)
>{
> return e1.address() == e2.address() && e1.port() == e2.port();
>}
>
>bool operator<(const endpoint& e1, const endpoint& e2)
>{
> if (e1.address() < e2.address())
> return true;
> if (e1.address() != e2.address())
> return false;
> return e1.port() < e2.port();
>}
>
>
>std::string endpoint::to_string() const
>{
> std::ostringstream tmp_os;
> tmp_os.imbue(std::locale::classic());
> if (is_v4())
> tmp_os << address();
> else
> tmp_os << '[' << address() << ']';
> tmp_os << ':' << port();
>
> return tmp_os.str();
>}
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 200 "/usr/include/boost/asio/ip/detail/impl/endpoint.ipp" 2 3 4
># 139 "/usr/include/boost/asio/ip/detail/endpoint.hpp" 2 3 4
># 21 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 44 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
>template <typename InternetProtocol>
>class basic_endpoint
>{
>public:
>
> typedef InternetProtocol protocol_type;
>
>
>
>
>
>
> typedef boost::asio::detail::socket_addr_type data_type;
>
>
>
> basic_endpoint()
> : impl_()
> {
> }
># 81 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
> basic_endpoint(const InternetProtocol& internet_protocol,
> unsigned short port_num)
> : impl_(internet_protocol.family(), port_num)
> {
> }
>
>
>
>
> basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
> : impl_(addr, port_num)
> {
> }
>
>
> basic_endpoint(const basic_endpoint& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint(basic_endpoint&& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint& operator=(const basic_endpoint& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> basic_endpoint& operator=(basic_endpoint&& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> protocol_type protocol() const
> {
> if (impl_.is_v4())
> return InternetProtocol::v4();
> return InternetProtocol::v6();
> }
>
>
> data_type* data()
> {
> return impl_.data();
> }
>
>
> const data_type* data() const
> {
> return impl_.data();
> }
>
>
> std::size_t size() const
> {
> return impl_.size();
> }
>
>
> void resize(std::size_t new_size)
> {
> impl_.resize(new_size);
> }
>
>
> std::size_t capacity() const
> {
> return impl_.capacity();
> }
>
>
>
> unsigned short port() const
> {
> return impl_.port();
> }
>
>
>
> void port(unsigned short port_num)
> {
> impl_.port(port_num);
> }
>
>
> boost::asio::ip::address address() const
> {
> return impl_.address();
> }
>
>
> void address(const boost::asio::ip::address& addr)
> {
> impl_.address(addr);
> }
>
>
> friend bool operator==(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return e1.impl_ == e2.impl_;
> }
>
>
> friend bool operator!=(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return !(e1 == e2);
> }
>
>
> friend bool operator<(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return e1.impl_ < e2.impl_;
> }
>
>
> friend bool operator>(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return e2.impl_ < e1.impl_;
> }
>
>
> friend bool operator<=(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return !(e2 < e1);
> }
>
>
> friend bool operator>=(const basic_endpoint<InternetProtocol>& e1,
> const basic_endpoint<InternetProtocol>& e2)
> {
> return !(e1 < e2);
> }
>
>private:
>
> boost::asio::ip::detail::endpoint impl_;
>};
># 250 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 3 4
>template <typename Elem, typename Traits, typename InternetProtocol>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os,
> const basic_endpoint<InternetProtocol>& endpoint);
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 262 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>template <typename Elem, typename Traits, typename InternetProtocol>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os,
> const basic_endpoint<InternetProtocol>& endpoint)
>{
> boost::asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
> return os << tmp_ep.to_string().c_str();
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 42 "/usr/include/boost/asio/ip/impl/basic_endpoint.hpp" 2 3 4
># 264 "/usr/include/boost/asio/ip/basic_endpoint.hpp" 2 3 4
># 80 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver.hpp" 1 3 4
># 27 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 21 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 37 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_entry
>{
>public:
>
> typedef InternetProtocol protocol_type;
>
>
> typedef typename InternetProtocol::endpoint endpoint_type;
>
>
> basic_resolver_entry()
> {
> }
>
>
> basic_resolver_entry(const endpoint_type& ep,
> boost::asio::string_view host, boost::asio::string_view service)
> : endpoint_(ep),
> host_name_(static_cast<std::string>(host)),
> service_name_(static_cast<std::string>(service))
> {
> }
>
>
> endpoint_type endpoint() const
> {
> return endpoint_;
> }
>
>
> operator endpoint_type() const
> {
> return endpoint_;
> }
>
>
> std::string host_name() const
> {
> return host_name_;
> }
>
>
> template <class Allocator>
> std::basic_string<char, std::char_traits<char>, Allocator> host_name(
> const Allocator& alloc = Allocator()) const
> {
> return std::basic_string<char, std::char_traits<char>, Allocator>(
> host_name_.c_str(), alloc);
> }
>
>
> std::string service_name() const
> {
> return service_name_;
> }
>
>
> template <class Allocator>
> std::basic_string<char, std::char_traits<char>, Allocator> service_name(
> const Allocator& alloc = Allocator()) const
> {
> return std::basic_string<char, std::char_traits<char>, Allocator>(
> service_name_.c_str(), alloc);
> }
>
>private:
> endpoint_type endpoint_;
> std::string host_name_;
> std::string service_name_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 114 "/usr/include/boost/asio/ip/basic_resolver_entry.hpp" 2 3 4
># 28 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 34 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 51 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_iterator
>{
>public:
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef basic_resolver_entry<InternetProtocol> value_type;
>
>
> typedef const basic_resolver_entry<InternetProtocol>* pointer;
>
>
> typedef const basic_resolver_entry<InternetProtocol>& reference;
>
>
> typedef std::forward_iterator_tag iterator_category;
>
>
> basic_resolver_iterator()
> : index_(0)
> {
> }
>
>
> basic_resolver_iterator(const basic_resolver_iterator& other)
> : values_(other.values_),
> index_(other.index_)
> {
> }
>
>
>
> basic_resolver_iterator(basic_resolver_iterator&& other)
> : values_(static_cast<values_ptr_type&&>(other.values_)),
> index_(other.index_)
> {
> other.index_ = 0;
> }
>
>
>
> basic_resolver_iterator& operator=(const basic_resolver_iterator& other)
> {
> values_ = other.values_;
> index_ = other.index_;
> return *this;
> }
>
>
>
> basic_resolver_iterator& operator=(basic_resolver_iterator&& other)
> {
> if (this != &other)
> {
> values_ = static_cast<values_ptr_type&&>(other.values_);
> index_ = other.index_;
> other.index_ = 0;
> }
>
> return *this;
> }
>
>
>
> const basic_resolver_entry<InternetProtocol>& operator*() const
> {
> return dereference();
> }
>
>
> const basic_resolver_entry<InternetProtocol>* operator->() const
> {
> return &dereference();
> }
>
>
> basic_resolver_iterator& operator++()
> {
> increment();
> return *this;
> }
>
>
> basic_resolver_iterator operator++(int)
> {
> basic_resolver_iterator tmp(*this);
> ++*this;
> return tmp;
> }
>
>
> friend bool operator==(const basic_resolver_iterator& a,
> const basic_resolver_iterator& b)
> {
> return a.equal(b);
> }
>
>
> friend bool operator!=(const basic_resolver_iterator& a,
> const basic_resolver_iterator& b)
> {
> return !a.equal(b);
> }
>
>protected:
> void increment()
> {
> if (++index_ == values_->size())
> {
>
> values_.reset();
> index_ = 0;
> }
> }
>
> bool equal(const basic_resolver_iterator& other) const
> {
> if (!values_ && !other.values_)
> return true;
> if (values_ != other.values_)
> return false;
> return index_ == other.index_;
> }
>
> const basic_resolver_entry<InternetProtocol>& dereference() const
> {
> return (*values_)[index_];
> }
>
> typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
> typedef boost::asio::detail::shared_ptr<values_type> values_ptr_type;
> values_ptr_type values_;
> std::size_t index_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 193 "/usr/include/boost/asio/ip/basic_resolver_iterator.hpp" 2 3 4
># 28 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/resolver_base.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/resolver_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ip/resolver_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>
>class resolver_base
>{
>public:
># 63 "/usr/include/boost/asio/ip/resolver_base.hpp" 3 4
> enum flags
> {
> canonical_name = 0x0002,
> passive = 0x0001,
> numeric_host = 0x0004,
> numeric_service = 0x0400,
> v4_mapped = 0x0008,
> all_matching = 0x0010,
> address_configured = 0x0020
> };
>
>
>
> friend flags operator&(flags x, flags y)
> {
> return static_cast<flags>(
> static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
> }
>
> friend flags operator|(flags x, flags y)
> {
> return static_cast<flags>(
> static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
> }
>
> friend flags operator^(flags x, flags y)
> {
> return static_cast<flags>(
> static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
> }
>
> friend flags operator~(flags x)
> {
> return static_cast<flags>(~static_cast<unsigned int>(x));
> }
>
> friend flags& operator&=(flags& x, flags y)
> {
> x = x & y;
> return x;
> }
>
> friend flags& operator|=(flags& x, flags y)
> {
> x = x | y;
> return x;
> }
>
> friend flags& operator^=(flags& x, flags y)
> {
> x = x ^ y;
> return x;
> }
>
>
>protected:
>
> ~resolver_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 130 "/usr/include/boost/asio/ip/resolver_base.hpp" 2 3 4
># 20 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>
>
>class resolver_query_base : public resolver_base
>{
>protected:
>
> ~resolver_query_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 44 "/usr/include/boost/asio/ip/resolver_query_base.hpp" 2 3 4
># 22 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 38 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_query
> : public resolver_query_base
>{
>public:
>
> typedef InternetProtocol protocol_type;
># 63 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const std::string& service,
> resolver_query_base::flags resolve_flags = passive | address_configured)
> : hints_(),
> host_name_(),
> service_name_(service)
> {
> typename InternetProtocol::endpoint endpoint;
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = 0;
> hints_.ai_socktype = endpoint.protocol().type();
> hints_.ai_protocol = endpoint.protocol().protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
># 100 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const protocol_type& protocol,
> const std::string& service,
> resolver_query_base::flags resolve_flags = passive | address_configured)
> : hints_(),
> host_name_(),
> service_name_(service)
> {
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = protocol.family();
> hints_.ai_socktype = protocol.type();
> hints_.ai_protocol = protocol.protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
># 148 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const std::string& host, const std::string& service,
> resolver_query_base::flags resolve_flags = address_configured)
> : hints_(),
> host_name_(host),
> service_name_(service)
> {
> typename InternetProtocol::endpoint endpoint;
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = 0;
> hints_.ai_socktype = endpoint.protocol().type();
> hints_.ai_protocol = endpoint.protocol().protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
># 199 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 3 4
> basic_resolver_query(const protocol_type& protocol,
> const std::string& host, const std::string& service,
> resolver_query_base::flags resolve_flags = address_configured)
> : hints_(),
> host_name_(host),
> service_name_(service)
> {
> hints_.ai_flags = static_cast<int>(resolve_flags);
> hints_.ai_family = protocol.family();
> hints_.ai_socktype = protocol.type();
> hints_.ai_protocol = protocol.protocol();
> hints_.ai_addrlen = 0;
> hints_.ai_canonname = 0;
> hints_.ai_addr = 0;
> hints_.ai_next = 0;
> }
>
>
> const boost::asio::detail::addrinfo_type& hints() const
> {
> return hints_;
> }
>
>
> std::string host_name() const
> {
> return host_name_;
> }
>
>
> std::string service_name() const
> {
> return service_name_;
> }
>
>private:
> boost::asio::detail::addrinfo_type hints_;
> std::string host_name_;
> std::string service_name_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 245 "/usr/include/boost/asio/ip/basic_resolver_query.hpp" 2 3 4
># 29 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 21 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 2 3 4
># 29 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 50 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
>template <typename InternetProtocol>
>class basic_resolver_results
>
> : public basic_resolver_iterator<InternetProtocol>
>
>
>
>{
>public:
>
> typedef InternetProtocol protocol_type;
>
>
> typedef typename protocol_type::endpoint endpoint_type;
>
>
> typedef basic_resolver_entry<endpoint_type> value_type;
>
>
> typedef const value_type& const_reference;
>
>
> typedef value_type& reference;
>
>
> typedef basic_resolver_iterator<protocol_type> const_iterator;
>
>
> typedef const_iterator iterator;
>
>
> typedef std::ptrdiff_t difference_type;
>
>
> typedef std::size_t size_type;
>
>
> basic_resolver_results()
> {
> }
>
>
> basic_resolver_results(const basic_resolver_results& other)
> : basic_resolver_iterator<InternetProtocol>(other)
> {
> }
>
>
>
> basic_resolver_results(basic_resolver_results&& other)
> : basic_resolver_iterator<InternetProtocol>(
> static_cast<basic_resolver_results&&>(other))
> {
> }
>
>
>
> basic_resolver_results& operator=(const basic_resolver_results& other)
> {
> basic_resolver_iterator<InternetProtocol>::operator=(other);
> return *this;
> }
>
>
>
> basic_resolver_results& operator=(basic_resolver_results&& other)
> {
> basic_resolver_iterator<InternetProtocol>::operator=(
> static_cast<basic_resolver_results&&>(other));
> return *this;
> }
>
>
>
>
> static basic_resolver_results create(
> boost::asio::detail::addrinfo_type* address_info,
> const std::string& host_name, const std::string& service_name)
> {
> basic_resolver_results results;
> if (!address_info)
> return results;
>
> std::string actual_host_name = host_name;
> if (address_info->ai_canonname)
> actual_host_name = address_info->ai_canonname;
>
> results.values_.reset(new values_type);
>
> while (address_info)
> {
> if (address_info->ai_family == 2
> || address_info->ai_family == 10)
> {
> using namespace std;
> typename InternetProtocol::endpoint endpoint;
> endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
> memcpy(endpoint.data(), address_info->ai_addr,
> address_info->ai_addrlen);
> results.values_->push_back(
> basic_resolver_entry<InternetProtocol>(endpoint,
> actual_host_name, service_name));
> }
> address_info = address_info->ai_next;
> }
>
> return results;
> }
>
>
> static basic_resolver_results create(const endpoint_type& endpoint,
> const std::string& host_name, const std::string& service_name)
> {
> basic_resolver_results results;
> results.values_.reset(new values_type);
> results.values_->push_back(
> basic_resolver_entry<InternetProtocol>(
> endpoint, host_name, service_name));
> return results;
> }
>
>
> template <typename EndpointIterator>
> static basic_resolver_results create(
> EndpointIterator begin, EndpointIterator end,
> const std::string& host_name, const std::string& service_name)
> {
> basic_resolver_results results;
> if (begin != end)
> {
> results.values_.reset(new values_type);
> for (EndpointIterator ep_iter = begin; ep_iter != end; ++ep_iter)
> {
> results.values_->push_back(
> basic_resolver_entry<InternetProtocol>(
> *ep_iter, host_name, service_name));
> }
> }
> return results;
> }
># 234 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 3 4
> size_type size() const noexcept
> {
> return this->values_->size();
> }
>
>
> size_type max_size() const noexcept
> {
> return this->values_->max_size();
> }
>
>
> bool empty() const noexcept
> {
> return this->values_->empty();
> }
>
>
> const_iterator begin() const
> {
> basic_resolver_results tmp(*this);
> tmp.index_ = 0;
> return tmp;
> }
>
>
> const_iterator end() const
> {
> return const_iterator();
> }
>
>
> const_iterator cbegin() const
> {
> return begin();
> }
>
>
> const_iterator cend() const
> {
> return end();
> }
>
>
> void swap(basic_resolver_results& that) noexcept
> {
> if (this != &that)
> {
> this->values_.swap(that.values_);
> std::size_t index = this->index_;
> this->index_ = that.index_;
> that.index_ = index;
> }
> }
>
>
> friend bool operator==(const basic_resolver_results& a,
> const basic_resolver_results& b)
> {
> return a.equal(b);
> }
>
>
> friend bool operator!=(const basic_resolver_results& a,
> const basic_resolver_results& b)
> {
> return !a.equal(b);
> }
>
>private:
> typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 312 "/usr/include/boost/asio/ip/basic_resolver_results.hpp" 2 3 4
># 30 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 44 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/resolver_service.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/resolver_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 1 3 4
># 27 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/resolve_op.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/resolve_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/detail/resolve_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class resolve_op : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>protected:
> resolve_op(func_type complete_func)
> : operation(complete_func)
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 46 "/usr/include/boost/asio/detail/resolve_op.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol, typename Handler>
>class resolve_endpoint_op : public resolve_op
>{
>public:
> struct ptr { Handler* h; resolve_endpoint_op* v; resolve_endpoint_op* p; ~ptr() { reset(); } static resolve_endpoint_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_endpoint_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~resolve_endpoint_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_endpoint_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<resolve_endpoint_op*>(v), 1); v = 0; } } };
>
> typedef typename Protocol::endpoint endpoint_type;
> typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;
>
> resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
> const endpoint_type& endpoint, io_context_impl& ioc, Handler& handler)
> : resolve_op(&resolve_endpoint_op::do_complete),
> cancel_token_(cancel_token),
> endpoint_(endpoint),
> io_context_impl_(ioc),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> if (owner && owner != &o->io_context_impl_)
> {
>
>
>
>
> char host_name[1025];
> char service_name[32];
> socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
> o->endpoint_.size(), host_name, 1025, service_name, 32,
> o->endpoint_.protocol().type(), o->ec_);
> o->results_ = results_type::create(o->endpoint_, host_name, service_name);
>
>
> o->io_context_impl_.post_deferred_completion(o);
> p.v = p.p = 0;
> }
> else
> {
>
>
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, results_type>
> handler(o->handler_, o->ec_, o->results_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
> }
>
>private:
> socket_ops::weak_cancel_token_type cancel_token_;
> endpoint_type endpoint_;
> io_context_impl& io_context_impl_;
> Handler handler_;
> results_type results_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 123 "/usr/include/boost/asio/detail/resolve_endpoint_op.hpp" 2 3 4
># 27 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/resolve_query_op.hpp" 1 3 4
># 31 "/usr/include/boost/asio/detail/resolve_query_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/detail/resolve_query_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol, typename Handler>
>class resolve_query_op : public resolve_op
>{
>public:
> struct ptr { Handler* h; resolve_query_op* v; resolve_query_op* p; ~ptr() { reset(); } static resolve_query_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_query_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~resolve_query_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<resolve_query_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<resolve_query_op*>(v), 1); v = 0; } } };
>
> typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
> typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;
>
> resolve_query_op(socket_ops::weak_cancel_token_type cancel_token,
> const query_type& query, io_context_impl& ioc, Handler& handler)
> : resolve_op(&resolve_query_op::do_complete),
> cancel_token_(cancel_token),
> query_(query),
> io_context_impl_(ioc),
> handler_(static_cast<Handler&&>(handler)),
> addrinfo_(0)
> {
> handler_work<Handler>::start(handler_);
> }
>
> ~resolve_query_op()
> {
> if (addrinfo_)
> socket_ops::freeaddrinfo(addrinfo_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> resolve_query_op* o(static_cast<resolve_query_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
>
> if (owner && owner != &o->io_context_impl_)
> {
>
>
>
>
> socket_ops::background_getaddrinfo(o->cancel_token_,
> o->query_.host_name().c_str(), o->query_.service_name().c_str(),
> o->query_.hints(), &o->addrinfo_, o->ec_);
>
>
> o->io_context_impl_.post_deferred_completion(o);
> p.v = p.p = 0;
> }
> else
> {
>
>
>
>
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, results_type>
> handler(o->handler_, o->ec_, results_type());
> p.h = boost::asio::detail::addressof(handler.handler_);
> if (o->addrinfo_)
> {
> handler.arg2_ = results_type::create(o->addrinfo_,
> o->query_.host_name(), o->query_.service_name());
> }
> p.reset();
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
> }
>
>private:
> socket_ops::weak_cancel_token_type cancel_token_;
> query_type query_;
> io_context_impl& io_context_impl_;
> Handler handler_;
> boost::asio::detail::addrinfo_type* addrinfo_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 135 "/usr/include/boost/asio/detail/resolve_query_op.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class resolver_service_base
>{
>public:
>
>
> typedef socket_ops::shared_cancel_token_type implementation_type;
>
>
> inline resolver_service_base(boost::asio::io_context& io_context);
>
>
> inline ~resolver_service_base();
>
>
> inline void base_shutdown();
>
>
> inline void base_notify_fork(
> boost::asio::io_context::fork_event fork_ev);
>
>
> inline void construct(implementation_type& impl);
>
>
> inline void destroy(implementation_type&);
>
>
> inline void move_construct(implementation_type& impl,
> implementation_type& other_impl);
>
>
> inline void move_assign(implementation_type& impl,
> resolver_service_base& other_service,
> implementation_type& other_impl);
>
>
> inline void cancel(implementation_type& impl);
>
>protected:
>
> inline void start_resolve_op(resolve_op* op);
>
>
>
> class auto_addrinfo
> : private boost::asio::detail::noncopyable
> {
> public:
> explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
> : ai_(ai)
> {
> }
>
> ~auto_addrinfo()
> {
> if (ai_)
> socket_ops::freeaddrinfo(ai_);
> }
>
> operator boost::asio::detail::addrinfo_type*()
> {
> return ai_;
> }
>
> private:
> boost::asio::detail::addrinfo_type* ai_;
> };
>
>
>
> class work_io_context_runner;
>
>
> inline void start_work_thread();
>
>
> io_context_impl& io_context_impl_;
>
>private:
>
> boost::asio::detail::mutex mutex_;
>
>
> boost::asio::detail::scoped_ptr<boost::asio::io_context> work_io_context_;
>
>
> io_context_impl& work_io_context_impl_;
>
>
> boost::asio::executor_work_guard<
> boost::asio::io_context::executor_type> work_;
>
>
> boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 137 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class resolver_service_base::work_io_context_runner
>{
>public:
> work_io_context_runner(boost::asio::io_context& io_context)
> : io_context_(io_context) {}
> void operator()() { io_context_.run(); }
>private:
> boost::asio::io_context& io_context_;
>};
>
>resolver_service_base::resolver_service_base(
> boost::asio::io_context& io_context)
> : io_context_impl_(boost::asio::use_service<io_context_impl>(io_context)),
> work_io_context_(new boost::asio::io_context(-1)),
> work_io_context_impl_(boost::asio::use_service<
> io_context_impl>(*work_io_context_)),
> work_(boost::asio::make_work_guard(*work_io_context_)),
> work_thread_(0)
>{
>}
>
>resolver_service_base::~resolver_service_base()
>{
> base_shutdown();
>}
>
>void resolver_service_base::base_shutdown()
>{
> work_.reset();
> if (work_io_context_.get())
> {
> work_io_context_->stop();
> if (work_thread_.get())
> {
> work_thread_->join();
> work_thread_.reset();
> }
> work_io_context_.reset();
> }
>}
>
>void resolver_service_base::base_notify_fork(
> boost::asio::io_context::fork_event fork_ev)
>{
> if (work_thread_.get())
> {
> if (fork_ev == boost::asio::io_context::fork_prepare)
> {
> work_io_context_->stop();
> work_thread_->join();
> }
> else
> {
> work_io_context_->restart();
> work_thread_.reset(new boost::asio::detail::thread(
> work_io_context_runner(*work_io_context_)));
> }
> }
>}
>
>void resolver_service_base::construct(
> resolver_service_base::implementation_type& impl)
>{
> impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
>}
>
>void resolver_service_base::destroy(
> resolver_service_base::implementation_type& impl)
>{
> (void)0
> ;
>
> impl.reset();
>}
>
>void resolver_service_base::move_construct(implementation_type& impl,
> implementation_type& other_impl)
>{
> impl = static_cast<implementation_type&&>(other_impl);
>}
>
>void resolver_service_base::move_assign(implementation_type& impl,
> resolver_service_base&, implementation_type& other_impl)
>{
> destroy(impl);
> impl = static_cast<implementation_type&&>(other_impl);
>}
>
>void resolver_service_base::cancel(
> resolver_service_base::implementation_type& impl)
>{
> (void)0
> ;
>
> impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
>}
>
>void resolver_service_base::start_resolve_op(resolve_op* op)
>{
> if ((((static_cast<unsigned>(io_context_impl_.concurrency_hint()) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
> )
> {
> start_work_thread();
> io_context_impl_.work_started();
> work_io_context_impl_.post_immediate_completion(op, false);
> }
> else
> {
> op->ec_ = boost::asio::error::operation_not_supported;
> io_context_impl_.post_immediate_completion(op, false);
> }
>}
>
>void resolver_service_base::start_work_thread()
>{
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
> if (!work_thread_.get())
> {
> work_thread_.reset(new boost::asio::detail::thread(
> work_io_context_runner(*work_io_context_)));
> }
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 155 "/usr/include/boost/asio/detail/impl/resolver_service_base.ipp" 2 3 4
># 140 "/usr/include/boost/asio/detail/resolver_service_base.hpp" 2 3 4
># 29 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Protocol>
>class resolver_service :
> public service_base<resolver_service<Protocol> >,
> public resolver_service_base
>{
>public:
>
>
> typedef socket_ops::shared_cancel_token_type implementation_type;
>
>
> typedef typename Protocol::endpoint endpoint_type;
>
>
> typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
>
>
> typedef boost::asio::ip::basic_resolver_results<Protocol> results_type;
>
>
> resolver_service(boost::asio::io_context& io_context)
> : service_base<resolver_service<Protocol> >(io_context),
> resolver_service_base(io_context)
> {
> }
>
>
> void shutdown()
> {
> this->base_shutdown();
> }
>
>
> void notify_fork(boost::asio::io_context::fork_event fork_ev)
> {
> this->base_notify_fork(fork_ev);
> }
>
>
> results_type resolve(implementation_type&, const query_type& query,
> boost::system::error_code& ec)
> {
> boost::asio::detail::addrinfo_type* address_info = 0;
>
> socket_ops::getaddrinfo(query.host_name().c_str(),
> query.service_name().c_str(), query.hints(), &address_info, ec);
> auto_addrinfo auto_address_info(address_info);
>
> return ec ? results_type() : results_type::create(
> address_info, query.host_name(), query.service_name());
> }
>
>
> template <typename Handler>
> void async_resolve(implementation_type& impl,
> const query_type& query, Handler& handler)
> {
>
> typedef resolve_query_op<Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl, query, io_context_impl_, handler);
>
> (void)0
> ;
>
> start_resolve_op(p.p);
> p.v = p.p = 0;
> }
>
>
> results_type resolve(implementation_type&,
> const endpoint_type& endpoint, boost::system::error_code& ec)
> {
> char host_name[1025];
> char service_name[32];
> socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(),
> host_name, 1025, service_name, 32,
> endpoint.protocol().type(), ec);
>
> return ec ? results_type() : results_type::create(
> endpoint, host_name, service_name);
> }
>
>
> template <typename Handler>
> void async_resolve(implementation_type& impl,
> const endpoint_type& endpoint, Handler& handler)
> {
>
> typedef resolve_endpoint_op<Protocol, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl, endpoint, io_context_impl_, handler);
>
> (void)0
> ;
>
> start_resolve_op(p.p);
> p.v = p.p = 0;
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 144 "/usr/include/boost/asio/detail/resolver_service.hpp" 2 3 4
># 45 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 51 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 65 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
>template <typename InternetProtocol
> >
>class basic_resolver
> : protected basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >,
> public resolver_base
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
> typedef InternetProtocol protocol_type;
>
>
> typedef typename InternetProtocol::endpoint endpoint_type;
>
>
>
> typedef basic_resolver_query<InternetProtocol> query;
>
>
> typedef basic_resolver_iterator<InternetProtocol> iterator;
>
>
>
> typedef basic_resolver_results<InternetProtocol> results_type;
># 100 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> explicit basic_resolver(boost::asio::io_context& io_context)
> : basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >(io_context)
> {
> }
># 116 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> basic_resolver(basic_resolver&& other)
> : basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >(std::move(other))
> {
> }
># 133 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> basic_resolver& operator=(basic_resolver&& other)
> {
> basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::operator=(std::move(other));
> return *this;
> }
># 146 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> ~basic_resolver()
> {
> }
># 163 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::get_io_context();
> }
># 177 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<boost::asio::detail::resolver_service<InternetProtocol> >::get_executor();
> }
># 196 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> void cancel()
> {
> return this->get_service().cancel(this->get_implementation());
> }
># 214 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const query& q)
> {
> boost::system::error_code ec;
> results_type r = this->get_service().resolve(
> this->get_implementation(), q, ec);
> boost::asio::detail::throw_error(ec, "resolve");
> return r;
> }
># 235 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const query& q, boost::system::error_code& ec)
> {
> return this->get_service().resolve(this->get_implementation(), q, ec);
> }
># 274 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(boost::asio::string_view host,
> boost::asio::string_view service)
> {
> return resolve(host, service, resolver_base::flags());
> }
># 313 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(boost::asio::string_view host,
> boost::asio::string_view service, boost::system::error_code& ec)
> {
> return resolve(host, service, resolver_base::flags(), ec);
> }
># 356 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(boost::asio::string_view host,
> boost::asio::string_view service, resolver_base::flags resolve_flags)
> {
> boost::system::error_code ec;
> basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
> static_cast<std::string>(service), resolve_flags);
> results_type r = this->get_service().resolve(
> this->get_implementation(), q, ec);
> boost::asio::detail::throw_error(ec, "resolve");
> return r;
> }
># 405 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(boost::asio::string_view host,
> boost::asio::string_view service, resolver_base::flags resolve_flags,
> boost::system::error_code& ec)
> {
> basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
> static_cast<std::string>(service), resolve_flags);
> return this->get_service().resolve(this->get_implementation(), q, ec);
> }
># 450 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const protocol_type& protocol,
> boost::asio::string_view host, boost::asio::string_view service)
> {
> return resolve(protocol, host, service, resolver_base::flags());
> }
># 492 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const protocol_type& protocol,
> boost::asio::string_view host, boost::asio::string_view service,
> boost::system::error_code& ec)
> {
> return resolve(protocol, host, service, resolver_base::flags(), ec);
> }
># 539 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const protocol_type& protocol,
> boost::asio::string_view host, boost::asio::string_view service,
> resolver_base::flags resolve_flags)
> {
> boost::system::error_code ec;
> basic_resolver_query<protocol_type> q(
> protocol, static_cast<std::string>(host),
> static_cast<std::string>(service), resolve_flags);
> results_type r = this->get_service().resolve(
> this->get_implementation(), q, ec);
> boost::asio::detail::throw_error(ec, "resolve");
> return r;
> }
># 593 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const protocol_type& protocol,
> boost::asio::string_view host, boost::asio::string_view service,
> resolver_base::flags resolve_flags, boost::system::error_code& ec)
> {
> basic_resolver_query<protocol_type> q(
> protocol, static_cast<std::string>(host),
> static_cast<std::string>(service), resolve_flags);
> return this->get_service().resolve(this->get_implementation(), q, ec);
> }
># 627 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type
>
> async_resolve(const query& q,
> ResolveHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
> type_check;
>
>
>
>
>
> boost::asio::async_completion<ResolveHandler,
> void (boost::system::error_code, results_type)> init(handler);
>
> this->get_service().async_resolve(
> this->get_implementation(), q, init.completion_handler);
>
> return init.result.get();
>
> }
># 695 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type
>
> async_resolve(boost::asio::string_view host,
> boost::asio::string_view service,
> ResolveHandler&& handler)
> {
> return async_resolve(host, service, resolver_base::flags(),
> static_cast<ResolveHandler&&>(handler));
> }
># 752 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type
>
> async_resolve(boost::asio::string_view host,
> boost::asio::string_view service,
> resolver_base::flags resolve_flags,
> ResolveHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
> type_check;
>
> basic_resolver_query<protocol_type> q(static_cast<std::string>(host),
> static_cast<std::string>(service), resolve_flags);
>
>
>
>
>
> boost::asio::async_completion<ResolveHandler,
> void (boost::system::error_code, results_type)> init(handler);
>
> this->get_service().async_resolve(
> this->get_implementation(), q, init.completion_handler);
>
> return init.result.get();
>
> }
># 827 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type
>
> async_resolve(const protocol_type& protocol,
> boost::asio::string_view host, boost::asio::string_view service,
> ResolveHandler&& handler)
> {
> return async_resolve(protocol, host, service, resolver_base::flags(),
> static_cast<ResolveHandler&&>(handler));
> }
># 887 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type
>
> async_resolve(const protocol_type& protocol,
> boost::asio::string_view host, boost::asio::string_view service,
> resolver_base::flags resolve_flags,
> ResolveHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
> type_check;
>
> basic_resolver_query<protocol_type> q(
> protocol, static_cast<std::string>(host),
> static_cast<std::string>(service), resolve_flags);
>
>
>
>
>
> boost::asio::async_completion<ResolveHandler,
> void (boost::system::error_code, results_type)> init(handler);
>
> this->get_service().async_resolve(
> this->get_implementation(), q, init.completion_handler);
>
> return init.result.get();
>
> }
># 932 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const endpoint_type& e)
> {
> boost::system::error_code ec;
> results_type i = this->get_service().resolve(
> this->get_implementation(), e, ec);
> boost::asio::detail::throw_error(ec, "resolve");
> return i;
> }
># 955 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> results_type resolve(const endpoint_type& e, boost::system::error_code& ec)
> {
> return this->get_service().resolve(this->get_implementation(), e, ec);
> }
># 984 "/usr/include/boost/asio/ip/basic_resolver.hpp" 3 4
> template <typename ResolveHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void (boost::system::error_code, results_type)>::return_type
>
> async_resolve(const endpoint_type& e,
> ResolveHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ResolveHandler>::type, void(boost::system::error_code, results_type)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const results_type*>(0))) == 1, "ResolveHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const results_type>()), char(0))> __attribute__((__unused__))
> type_check;
>
>
>
>
>
> boost::asio::async_completion<ResolveHandler,
> void (boost::system::error_code, results_type)> init(handler);
>
> this->get_service().async_resolve(
> this->get_implementation(), e, init.completion_handler);
>
> return init.result.get();
>
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1015 "/usr/include/boost/asio/ip/basic_resolver.hpp" 2 3 4
># 81 "/usr/include/boost/asio.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/ip/host_name.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/host_name.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/host_name.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>
>inline std::string host_name();
>
>
>inline std::string host_name(boost::system::error_code& ec);
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 39 "/usr/include/boost/asio/ip/host_name.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/impl/host_name.ipp" 1 3 4
># 22 "/usr/include/boost/asio/ip/impl/host_name.ipp" 3 4
># 1 "/usr/include/boost/asio/ip/host_name.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>
>std::string host_name()
>{
> char name[1024];
> boost::system::error_code ec;
> if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
> {
> boost::asio::detail::throw_error(ec);
> return std::string();
> }
> return std::string(name);
>}
>
>std::string host_name(boost::system::error_code& ec)
>{
> char name[1024];
> if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
> return std::string();
> return std::string(name);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 55 "/usr/include/boost/asio/ip/impl/host_name.ipp" 2 3 4
># 42 "/usr/include/boost/asio/ip/host_name.hpp" 2 3 4
># 85 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/icmp.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ip/icmp.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/ip/icmp.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 43 "/usr/include/boost/asio/ip/icmp.hpp" 3 4
>class icmp
>{
>public:
>
> typedef basic_endpoint<icmp> endpoint;
>
>
> static icmp v4()
> {
> return icmp(IPPROTO_ICMP,
> 2);
> }
>
>
> static icmp v6()
> {
> return icmp(IPPROTO_ICMPV6,
> 10);
> }
>
>
> int type() const
> {
> return SOCK_RAW;
> }
>
>
> int protocol() const
> {
> return protocol_;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> typedef basic_raw_socket<icmp> socket;
>
>
> typedef basic_resolver<icmp> resolver;
>
>
> friend bool operator==(const icmp& p1, const icmp& p2)
> {
> return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_;
> }
>
>
> friend bool operator!=(const icmp& p1, const icmp& p2)
> {
> return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_;
> }
>
>private:
>
> explicit icmp(int protocol_id, int protocol_family)
> : protocol_(protocol_id),
> family_(protocol_family)
> {
> }
>
> int protocol_;
> int family_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 116 "/usr/include/boost/asio/ip/icmp.hpp" 2 3 4
># 86 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/multicast.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
># 1 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 21 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace detail {
>namespace socket_option {
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class multicast_enable_loopback
>{
>public:
>
>
>
>
>
>
>
> typedef int ipv4_value_type;
> typedef int ipv6_value_type;
>
>
>
> multicast_enable_loopback()
> : ipv4_value_(0),
> ipv6_value_(0)
> {
> }
>
>
> explicit multicast_enable_loopback(bool v)
> : ipv4_value_(v ? 1 : 0),
> ipv6_value_(v ? 1 : 0)
> {
> }
>
>
> multicast_enable_loopback& operator=(bool v)
> {
> ipv4_value_ = v ? 1 : 0;
> ipv6_value_ = v ? 1 : 0;
> return *this;
> }
>
>
> bool value() const
> {
> return !!ipv4_value_;
> }
>
>
> operator bool() const
> {
> return !!ipv4_value_;
> }
>
>
> bool operator!() const
> {
> return !ipv4_value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> void* data(const Protocol& protocol)
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol& protocol, std::size_t s)
> {
> if (protocol.family() == 10)
> {
> if (s != sizeof(ipv6_value_))
> {
> std::length_error ex("multicast_enable_loopback socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> ipv4_value_ = ipv6_value_ ? 1 : 0;
> }
> else
> {
> if (s != sizeof(ipv4_value_))
> {
> std::length_error ex("multicast_enable_loopback socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> ipv6_value_ = ipv4_value_ ? 1 : 0;
> }
> }
>
>private:
> ipv4_value_type ipv4_value_;
> ipv6_value_type ipv6_value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class unicast_hops
>{
>public:
>
> unicast_hops()
> : value_(0)
> {
> }
>
>
> explicit unicast_hops(int v)
> : value_(v)
> {
> }
>
>
> unicast_hops& operator=(int v)
> {
> value_ = v;
> return *this;
> }
>
>
> int value() const
> {
> return value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> int* data(const Protocol&)
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> const int* data(const Protocol&) const
> {
> return &value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol&) const
> {
> return sizeof(value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol&, std::size_t s)
> {
> if (s != sizeof(value_))
> {
> std::length_error ex("unicast hops socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
>
>
>
>
> }
>
>private:
> int value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class multicast_hops
>{
>public:
>
>
>
> typedef unsigned char ipv4_value_type;
>
> typedef int ipv6_value_type;
>
>
> multicast_hops()
> : ipv4_value_(0),
> ipv6_value_(0)
> {
> }
>
>
> explicit multicast_hops(int v)
> {
> if (v < 0 || v > 255)
> {
> std::out_of_range ex("multicast hops value out of range");
> boost::asio::detail::throw_exception(ex);
> }
> ipv4_value_ = (ipv4_value_type)v;
> ipv6_value_ = v;
> }
>
>
> multicast_hops& operator=(int v)
> {
> if (v < 0 || v > 255)
> {
> std::out_of_range ex("multicast hops value out of range");
> boost::asio::detail::throw_exception(ex);
> }
> ipv4_value_ = (ipv4_value_type)v;
> ipv6_value_ = v;
> return *this;
> }
>
>
> int value() const
> {
> return ipv6_value_;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> void* data(const Protocol& protocol)
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>
> template <typename Protocol>
> void resize(const Protocol& protocol, std::size_t s)
> {
> if (protocol.family() == 10)
> {
> if (s != sizeof(ipv6_value_))
> {
> std::length_error ex("multicast hops socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> if (ipv6_value_ < 0)
> ipv4_value_ = 0;
> else if (ipv6_value_ > 255)
> ipv4_value_ = 255;
> else
> ipv4_value_ = (ipv4_value_type)ipv6_value_;
> }
> else
> {
> if (s != sizeof(ipv4_value_))
> {
> std::length_error ex("multicast hops socket option resize");
> boost::asio::detail::throw_exception(ex);
> }
> ipv6_value_ = ipv4_value_;
> }
> }
>
>private:
> ipv4_value_type ipv4_value_;
> ipv6_value_type ipv6_value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class multicast_request
>{
>public:
>
> multicast_request()
> : ipv4_value_(),
> ipv6_value_()
> {
> }
>
>
> explicit multicast_request(const address& multicast_address)
> : ipv4_value_(),
> ipv6_value_()
> {
> if (multicast_address.is_v6())
> {
> using namespace std;
> address_v6 ipv6_address = multicast_address.to_v6();
> address_v6::bytes_type bytes = ipv6_address.to_bytes();
> memcpy(ipv6_value_.ipv6mr_multiaddr.__in6_u.__u6_addr8, bytes.data(), 16);
> ipv6_value_.ipv6mr_interface = ipv6_address.scope_id();
> }
> else
> {
> ipv4_value_.imr_multiaddr.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> multicast_address.to_v4().to_uint());
> ipv4_value_.imr_interface.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> address_v4::any().to_uint());
> }
> }
>
>
> explicit multicast_request(const address_v4& multicast_address,
> const address_v4& network_interface = address_v4::any())
> : ipv6_value_()
> {
> ipv4_value_.imr_multiaddr.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> multicast_address.to_uint());
> ipv4_value_.imr_interface.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> network_interface.to_uint());
> }
>
>
> explicit multicast_request(
> const address_v6& multicast_address,
> unsigned long network_interface = 0)
> : ipv4_value_()
> {
> using namespace std;
> address_v6::bytes_type bytes = multicast_address.to_bytes();
> memcpy(ipv6_value_.ipv6mr_multiaddr.__in6_u.__u6_addr8, bytes.data(), 16);
> if (network_interface)
> ipv6_value_.ipv6mr_interface = network_interface;
> else
> ipv6_value_.ipv6mr_interface = multicast_address.scope_id();
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>private:
> boost::asio::detail::in4_mreq_type ipv4_value_;
> boost::asio::detail::in6_mreq_type ipv6_value_;
>};
>
>
>template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
>class network_interface
>{
>public:
>
> network_interface()
> {
> ipv4_value_.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> address_v4::any().to_uint());
> ipv6_value_ = 0;
> }
>
>
> explicit network_interface(const address_v4& ipv4_interface)
> {
> ipv4_value_.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> ipv4_interface.to_uint());
> ipv6_value_ = 0;
> }
>
>
> explicit network_interface(unsigned int ipv6_interface)
> {
> ipv4_value_.s_addr =
> boost::asio::detail::socket_ops::host_to_network_long(
> address_v4::any().to_uint());
> ipv6_value_ = ipv6_interface;
> }
>
>
> template <typename Protocol>
> int level(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Level;
> return IPv4_Level;
> }
>
>
> template <typename Protocol>
> int name(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return IPv6_Name;
> return IPv4_Name;
> }
>
>
> template <typename Protocol>
> const void* data(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return &ipv6_value_;
> return &ipv4_value_;
> }
>
>
> template <typename Protocol>
> std::size_t size(const Protocol& protocol) const
> {
> if (protocol.family() == 10)
> return sizeof(ipv6_value_);
> return sizeof(ipv4_value_);
> }
>
>private:
> boost::asio::detail::in4_addr_type ipv4_value_;
> unsigned int ipv6_value_;
>};
>
>}
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 567 "/usr/include/boost/asio/ip/detail/socket_option.hpp" 2 3 4
># 21 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace multicast {
># 50 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_request<
> IPPROTO_IP,
> 35,
> IPPROTO_IPV6,
> 20> join_group;
># 78 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_request<
> IPPROTO_IP,
> 36,
> IPPROTO_IPV6,
> 21> leave_group;
># 106 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::network_interface<
> IPPROTO_IP,
> 32,
> IPPROTO_IPV6,
> 17> outbound_interface;
># 142 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_hops<
> IPPROTO_IP,
> 33,
> IPPROTO_IPV6,
> 18> hops;
># 179 "/usr/include/boost/asio/ip/multicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
> IPPROTO_IP,
> 34,
> IPPROTO_IPV6,
> 19> enable_loopback;
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 192 "/usr/include/boost/asio/ip/multicast.hpp" 2 3 4
># 87 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ip/resolver_service.hpp" 1 3 4
># 90 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/tcp.hpp" 1 3 4
># 29 "/usr/include/boost/asio/ip/tcp.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/ip/tcp.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 46 "/usr/include/boost/asio/ip/tcp.hpp" 3 4
>class tcp
>{
>public:
>
> typedef basic_endpoint<tcp> endpoint;
>
>
> static tcp v4()
> {
> return tcp(2);
> }
>
>
> static tcp v6()
> {
> return tcp(10);
> }
>
>
> int type() const
> {
> return SOCK_STREAM;
> }
>
>
> int protocol() const
> {
> return IPPROTO_TCP;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> typedef basic_stream_socket<tcp> socket;
>
>
> typedef basic_socket_acceptor<tcp> acceptor;
>
>
> typedef basic_resolver<tcp> resolver;
>
>
>
> typedef basic_socket_iostream<tcp> iostream;
># 125 "/usr/include/boost/asio/ip/tcp.hpp" 3 4
> typedef boost::asio::detail::socket_option::boolean<
> IPPROTO_TCP, 1> no_delay;
>
>
>
> friend bool operator==(const tcp& p1, const tcp& p2)
> {
> return p1.family_ == p2.family_;
> }
>
>
> friend bool operator!=(const tcp& p1, const tcp& p2)
> {
> return p1.family_ != p2.family_;
> }
>
>private:
>
> explicit tcp(int protocol_family)
> : family_(protocol_family)
> {
> }
>
> int family_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 156 "/usr/include/boost/asio/ip/tcp.hpp" 2 3 4
># 91 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/udp.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ip/udp.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/ip/udp.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 43 "/usr/include/boost/asio/ip/udp.hpp" 3 4
>class udp
>{
>public:
>
> typedef basic_endpoint<udp> endpoint;
>
>
> static udp v4()
> {
> return udp(2);
> }
>
>
> static udp v6()
> {
> return udp(10);
> }
>
>
> int type() const
> {
> return SOCK_DGRAM;
> }
>
>
> int protocol() const
> {
> return IPPROTO_UDP;
> }
>
>
> int family() const
> {
> return family_;
> }
>
>
> typedef basic_datagram_socket<udp> socket;
>
>
> typedef basic_resolver<udp> resolver;
>
>
> friend bool operator==(const udp& p1, const udp& p2)
> {
> return p1.family_ == p2.family_;
> }
>
>
> friend bool operator!=(const udp& p1, const udp& p2)
> {
> return p1.family_ != p2.family_;
> }
>
>private:
>
> explicit udp(int protocol_family)
> : family_(protocol_family)
> {
> }
>
> int family_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 112 "/usr/include/boost/asio/ip/udp.hpp" 2 3 4
># 92 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/unicast.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ip/unicast.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ip/unicast.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
>namespace unicast {
># 58 "/usr/include/boost/asio/ip/unicast.hpp" 3 4
>typedef boost::asio::ip::detail::socket_option::unicast_hops<
> IPPROTO_IP,
> 2,
> IPPROTO_IPV6,
> 16> hops;
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 71 "/usr/include/boost/asio/ip/unicast.hpp" 2 3 4
># 93 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ip/v6_only.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ip/v6_only.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ip/v6_only.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ip {
># 57 "/usr/include/boost/asio/ip/v6_only.hpp" 3 4
>typedef boost::asio::detail::socket_option::boolean<
> IPPROTO_IPV6, 26> v6_only;
>
>
>
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 70 "/usr/include/boost/asio/ip/v6_only.hpp" 2 3 4
># 94 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/is_read_buffered.hpp" 1 3 4
># 22 "/usr/include/boost/asio/is_read_buffered.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/is_read_buffered.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>template <typename Stream>
>char is_read_buffered_helper(buffered_stream<Stream>* s);
>
>template <typename Stream>
>char is_read_buffered_helper(buffered_read_stream<Stream>* s);
>
>struct is_read_buffered_big_type { char data[10]; };
>is_read_buffered_big_type is_read_buffered_helper(...);
>
>}
>
>
>
>template <typename Stream>
>class is_read_buffered
>{
>public:
>
>
>
>
>
> static const bool value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1
> ;
>
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 60 "/usr/include/boost/asio/is_read_buffered.hpp" 2 3 4
># 96 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/is_write_buffered.hpp" 1 3 4
># 22 "/usr/include/boost/asio/is_write_buffered.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/is_write_buffered.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail {
>
>template <typename Stream>
>char is_write_buffered_helper(buffered_stream<Stream>* s);
>
>template <typename Stream>
>char is_write_buffered_helper(buffered_write_stream<Stream>* s);
>
>struct is_write_buffered_big_type { char data[10]; };
>is_write_buffered_big_type is_write_buffered_helper(...);
>
>}
>
>
>
>template <typename Stream>
>class is_write_buffered
>{
>public:
>
>
>
>
>
> static const bool value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1
> ;
>
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 60 "/usr/include/boost/asio/is_write_buffered.hpp" 2 3 4
># 97 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/basic_endpoint.hpp" 1 3 4
># 24 "/usr/include/boost/asio/local/basic_endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/local/detail/endpoint.hpp" 1 3 4
># 27 "/usr/include/boost/asio/local/detail/endpoint.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
>namespace detail {
>
>
>class endpoint
>{
>public:
>
> inline endpoint();
>
>
> inline endpoint(const char* path_name);
>
>
> inline endpoint(const std::string& path_name);
>
>
> endpoint(const endpoint& other)
> : data_(other.data_),
> path_length_(other.path_length_)
> {
> }
>
>
> endpoint& operator=(const endpoint& other)
> {
> data_ = other.data_;
> path_length_ = other.path_length_;
> return *this;
> }
>
>
> boost::asio::detail::socket_addr_type* data()
> {
> return &data_.base;
> }
>
>
> const boost::asio::detail::socket_addr_type* data() const
> {
> return &data_.base;
> }
>
>
> std::size_t size() const
> {
> return path_length_
> + __builtin_offsetof (boost::asio::detail::sockaddr_un_type, sun_path);
> }
>
>
> inline void resize(std::size_t size);
>
>
> std::size_t capacity() const
> {
> return sizeof(boost::asio::detail::sockaddr_un_type);
> }
>
>
> inline std::string path() const;
>
>
> inline void path(const char* p);
>
>
> inline void path(const std::string& p);
>
>
> inline friend bool operator==(
> const endpoint& e1, const endpoint& e2);
>
>
> inline friend bool operator<(
> const endpoint& e1, const endpoint& e2);
>
>private:
>
> union data_union
> {
> boost::asio::detail::socket_addr_type base;
> boost::asio::detail::sockaddr_un_type local;
> } data_;
>
>
> std::size_t path_length_;
>
>
> inline void init(const char* path, std::size_t path_length);
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 128 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 1 3 4
># 23 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 24 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/local/detail/endpoint.hpp" 1 3 4
># 28 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
>namespace detail {
>
>endpoint::endpoint()
>{
> init("", 0);
>}
>
>endpoint::endpoint(const char* path_name)
>{
> using namespace std;
> init(path_name, strlen(path_name));
>}
>
>endpoint::endpoint(const std::string& path_name)
>{
> init(path_name.data(), path_name.length());
>}
>
>void endpoint::resize(std::size_t new_size)
>{
> if (new_size > sizeof(boost::asio::detail::sockaddr_un_type))
> {
> boost::system::error_code ec(boost::asio::error::invalid_argument);
> boost::asio::detail::throw_error(ec);
> }
> else if (new_size == 0)
> {
> path_length_ = 0;
> }
> else
> {
> path_length_ = new_size
> - __builtin_offsetof (boost::asio::detail::sockaddr_un_type, sun_path);
>
>
> if (path_length_ > 0 && data_.local.sun_path[path_length_ - 1] == 0)
> --path_length_;
> }
>}
>
>std::string endpoint::path() const
>{
> return std::string(data_.local.sun_path, path_length_);
>}
>
>void endpoint::path(const char* p)
>{
> using namespace std;
> init(p, strlen(p));
>}
>
>void endpoint::path(const std::string& p)
>{
> init(p.data(), p.length());
>}
>
>bool operator==(const endpoint& e1, const endpoint& e2)
>{
> return e1.path() == e2.path();
>}
>
>bool operator<(const endpoint& e1, const endpoint& e2)
>{
> return e1.path() < e2.path();
>}
>
>void endpoint::init(const char* path_name, std::size_t path_length)
>{
> if (path_length > sizeof(data_.local.sun_path) - 1)
> {
>
> boost::system::error_code ec(boost::asio::error::name_too_long);
> boost::asio::detail::throw_error(ec);
> }
>
> using namespace std;
> data_.local = boost::asio::detail::sockaddr_un_type();
> data_.local.sun_family = 1;
> if (path_length > 0)
> memcpy(data_.local.sun_path, path_name, path_length);
> path_length_ = path_length;
>
>
>
> if (path_length > 0 && data_.local.sun_path[0] == 0)
> data_.local.sun_path[path_length] = 0;
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 128 "/usr/include/boost/asio/local/detail/impl/endpoint.ipp" 2 3 4
># 131 "/usr/include/boost/asio/local/detail/endpoint.hpp" 2 3 4
># 25 "/usr/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
># 48 "/usr/include/boost/asio/local/basic_endpoint.hpp" 3 4
>template <typename Protocol>
>class basic_endpoint
>{
>public:
>
> typedef Protocol protocol_type;
>
>
>
>
>
>
> typedef boost::asio::detail::socket_addr_type data_type;
>
>
>
> basic_endpoint()
> {
> }
>
>
> basic_endpoint(const char* path_name)
> : impl_(path_name)
> {
> }
>
>
> basic_endpoint(const std::string& path_name)
> : impl_(path_name)
> {
> }
>
>
> basic_endpoint(const basic_endpoint& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint(basic_endpoint&& other)
> : impl_(other.impl_)
> {
> }
>
>
>
> basic_endpoint& operator=(const basic_endpoint& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> basic_endpoint& operator=(basic_endpoint&& other)
> {
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> protocol_type protocol() const
> {
> return protocol_type();
> }
>
>
> data_type* data()
> {
> return impl_.data();
> }
>
>
> const data_type* data() const
> {
> return impl_.data();
> }
>
>
> std::size_t size() const
> {
> return impl_.size();
> }
>
>
> void resize(std::size_t new_size)
> {
> impl_.resize(new_size);
> }
>
>
> std::size_t capacity() const
> {
> return impl_.capacity();
> }
>
>
> std::string path() const
> {
> return impl_.path();
> }
>
>
> void path(const char* p)
> {
> impl_.path(p);
> }
>
>
> void path(const std::string& p)
> {
> impl_.path(p);
> }
>
>
> friend bool operator==(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ == e2.impl_;
> }
>
>
> friend bool operator!=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1.impl_ == e2.impl_);
> }
>
>
> friend bool operator<(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e1.impl_ < e2.impl_;
> }
>
>
> friend bool operator>(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return e2.impl_ < e1.impl_;
> }
>
>
> friend bool operator<=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e2 < e1);
> }
>
>
> friend bool operator>=(const basic_endpoint<Protocol>& e1,
> const basic_endpoint<Protocol>& e2)
> {
> return !(e1 < e2);
> }
>
>private:
>
> boost::asio::local::detail::endpoint impl_;
>};
># 223 "/usr/include/boost/asio/local/basic_endpoint.hpp" 3 4
>template <typename Elem, typename Traits, typename Protocol>
>std::basic_ostream<Elem, Traits>& operator<<(
> std::basic_ostream<Elem, Traits>& os,
> const basic_endpoint<Protocol>& endpoint)
>{
> os << endpoint.path();
> return os;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 237 "/usr/include/boost/asio/local/basic_endpoint.hpp" 2 3 4
># 98 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/connect_pair.hpp" 1 3 4
># 29 "/usr/include/boost/asio/local/connect_pair.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/local/connect_pair.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
>
>
>template <typename Protocol >
>void connect_pair(
> basic_socket<Protocol >& socket1,
> basic_socket<Protocol >& socket2);
>
>
>template <typename Protocol >
>boost::system::error_code connect_pair(
> basic_socket<Protocol >& socket1,
> basic_socket<Protocol >& socket2,
> boost::system::error_code& ec);
>
>template <typename Protocol >
>inline void connect_pair(
> basic_socket<Protocol >& socket1,
> basic_socket<Protocol >& socket2)
>{
> boost::system::error_code ec;
> connect_pair(socket1, socket2, ec);
> boost::asio::detail::throw_error(ec, "connect_pair");
>}
>
>template <typename Protocol >
>inline boost::system::error_code connect_pair(
> basic_socket<Protocol >& socket1,
> basic_socket<Protocol >& socket2,
> boost::system::error_code& ec)
>{
>
> boost::asio::local::basic_endpoint<Protocol>* tmp
> = static_cast<typename Protocol::endpoint*>(0);
> (void)tmp;
>
> Protocol protocol;
> boost::asio::detail::socket_type sv[2];
> if (boost::asio::detail::socket_ops::socketpair(protocol.family(),
> protocol.type(), protocol.protocol(), sv, ec)
> == boost::asio::detail::socket_error_retval)
> return ec;
>
> socket1.assign(protocol, sv[0], ec);
> if (ec)
> {
> boost::system::error_code temp_ec;
> boost::asio::detail::socket_ops::state_type state[2] = { 0, 0 };
> boost::asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec);
> boost::asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec);
> return ec;
> }
>
> socket2.assign(protocol, sv[1], ec);
> if (ec)
> {
> boost::system::error_code temp_ec;
> socket1.close(temp_ec);
> boost::asio::detail::socket_ops::state_type state = 0;
> boost::asio::detail::socket_ops::close(sv[1], state, true, temp_ec);
> return ec;
> }
>
> return ec;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 104 "/usr/include/boost/asio/local/connect_pair.hpp" 2 3 4
># 99 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/datagram_protocol.hpp" 1 3 4
># 27 "/usr/include/boost/asio/local/datagram_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/local/datagram_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
># 45 "/usr/include/boost/asio/local/datagram_protocol.hpp" 3 4
>class datagram_protocol
>{
>public:
>
> int type() const
> {
> return SOCK_DGRAM;
> }
>
>
> int protocol() const
> {
> return 0;
> }
>
>
> int family() const
> {
> return 1;
> }
>
>
> typedef basic_endpoint<datagram_protocol> endpoint;
>
>
> typedef basic_datagram_socket<datagram_protocol> socket;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 78 "/usr/include/boost/asio/local/datagram_protocol.hpp" 2 3 4
># 100 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/local/stream_protocol.hpp" 1 3 4
># 29 "/usr/include/boost/asio/local/stream_protocol.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/local/stream_protocol.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace local {
># 47 "/usr/include/boost/asio/local/stream_protocol.hpp" 3 4
>class stream_protocol
>{
>public:
>
> int type() const
> {
> return SOCK_STREAM;
> }
>
>
> int protocol() const
> {
> return 0;
> }
>
>
> int family() const
> {
> return 1;
> }
>
>
> typedef basic_endpoint<stream_protocol> endpoint;
>
>
> typedef basic_stream_socket<stream_protocol> socket;
>
>
> typedef basic_socket_acceptor<stream_protocol> acceptor;
>
>
>
> typedef basic_socket_iostream<stream_protocol> iostream;
>
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 88 "/usr/include/boost/asio/local/stream_protocol.hpp" 2 3 4
># 101 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/packaged_task.hpp" 1 3 4
># 23 "/usr/include/boost/asio/packaged_task.hpp" 3 4
># 1 "/usr/include/c++/8/future" 1 3 4
># 32 "/usr/include/c++/8/future" 3 4
> 
># 33 "/usr/include/c++/8/future" 3
>
>
>
>
>
># 1 "/usr/include/c++/8/mutex" 1 3
># 32 "/usr/include/c++/8/mutex" 3
> 
># 33 "/usr/include/c++/8/mutex" 3
># 43 "/usr/include/c++/8/mutex" 3
># 1 "/usr/include/c++/8/bits/std_mutex.h" 1 3
># 33 "/usr/include/c++/8/bits/std_mutex.h" 3
> 
># 34 "/usr/include/c++/8/bits/std_mutex.h" 3
># 46 "/usr/include/c++/8/bits/std_mutex.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 60 "/usr/include/c++/8/bits/std_mutex.h" 3
> class __mutex_base
> {
> protected:
> typedef __gthread_mutex_t __native_type;
>
>
> __native_type _M_mutex = { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } };
>
> constexpr __mutex_base() noexcept = default;
># 81 "/usr/include/c++/8/bits/std_mutex.h" 3
> __mutex_base(const __mutex_base&) = delete;
> __mutex_base& operator=(const __mutex_base&) = delete;
> };
>
>
> class mutex : private __mutex_base
> {
> public:
> typedef __native_type* native_handle_type;
>
>
> constexpr
>
> mutex() noexcept = default;
> ~mutex() = default;
>
> mutex(const mutex&) = delete;
> mutex& operator=(const mutex&) = delete;
>
> void
> lock()
> {
> int __e = __gthread_mutex_lock(&_M_mutex);
>
>
> if (__e)
> __throw_system_error(__e);
> }
>
> bool
> try_lock() noexcept
> {
>
> return !__gthread_mutex_trylock(&_M_mutex);
> }
>
> void
> unlock()
> {
>
> __gthread_mutex_unlock(&_M_mutex);
> }
>
> native_handle_type
> native_handle() noexcept
> { return &_M_mutex; }
> };
>
>
>
>
> struct defer_lock_t { explicit defer_lock_t() = default; };
>
>
> struct try_to_lock_t { explicit try_to_lock_t() = default; };
>
>
>
> struct adopt_lock_t { explicit adopt_lock_t() = default; };
>
>
> inline constexpr defer_lock_t defer_lock { };
>
>
> inline constexpr try_to_lock_t try_to_lock { };
>
>
> inline constexpr adopt_lock_t adopt_lock { };
>
>
>
>
>
>
> template<typename _Mutex>
> class lock_guard
> {
> public:
> typedef _Mutex mutex_type;
>
> explicit lock_guard(mutex_type& __m) : _M_device(__m)
> { _M_device.lock(); }
>
> lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m)
> { }
>
> ~lock_guard()
> { _M_device.unlock(); }
>
> lock_guard(const lock_guard&) = delete;
> lock_guard& operator=(const lock_guard&) = delete;
>
> private:
> mutex_type& _M_device;
> };
># 184 "/usr/include/c++/8/bits/std_mutex.h" 3
> template<typename _Mutex>
> class unique_lock
> {
> public:
> typedef _Mutex mutex_type;
>
> unique_lock() noexcept
> : _M_device(0), _M_owns(false)
> { }
>
> explicit unique_lock(mutex_type& __m)
> : _M_device(std::__addressof(__m)), _M_owns(false)
> {
> lock();
> _M_owns = true;
> }
>
> unique_lock(mutex_type& __m, defer_lock_t) noexcept
> : _M_device(std::__addressof(__m)), _M_owns(false)
> { }
>
> unique_lock(mutex_type& __m, try_to_lock_t)
> : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock())
> { }
>
> unique_lock(mutex_type& __m, adopt_lock_t) noexcept
> : _M_device(std::__addressof(__m)), _M_owns(true)
> {
>
> }
>
> template<typename _Clock, typename _Duration>
> unique_lock(mutex_type& __m,
> const chrono::time_point<_Clock, _Duration>& __atime)
> : _M_device(std::__addressof(__m)),
> _M_owns(_M_device->try_lock_until(__atime))
> { }
>
> template<typename _Rep, typename _Period>
> unique_lock(mutex_type& __m,
> const chrono::duration<_Rep, _Period>& __rtime)
> : _M_device(std::__addressof(__m)),
> _M_owns(_M_device->try_lock_for(__rtime))
> { }
>
> ~unique_lock()
> {
> if (_M_owns)
> unlock();
> }
>
> unique_lock(const unique_lock&) = delete;
> unique_lock& operator=(const unique_lock&) = delete;
>
> unique_lock(unique_lock&& __u) noexcept
> : _M_device(__u._M_device), _M_owns(__u._M_owns)
> {
> __u._M_device = 0;
> __u._M_owns = false;
> }
>
> unique_lock& operator=(unique_lock&& __u) noexcept
> {
> if(_M_owns)
> unlock();
>
> unique_lock(std::move(__u)).swap(*this);
>
> __u._M_device = 0;
> __u._M_owns = false;
>
> return *this;
> }
>
> void
> lock()
> {
> if (!_M_device)
> __throw_system_error(int(errc::operation_not_permitted));
> else if (_M_owns)
> __throw_system_error(int(errc::resource_deadlock_would_occur));
> else
> {
> _M_device->lock();
> _M_owns = true;
> }
> }
>
> bool
> try_lock()
> {
> if (!_M_device)
> __throw_system_error(int(errc::operation_not_permitted));
> else if (_M_owns)
> __throw_system_error(int(errc::resource_deadlock_would_occur));
> else
> {
> _M_owns = _M_device->try_lock();
> return _M_owns;
> }
> }
>
> template<typename _Clock, typename _Duration>
> bool
> try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
> {
> if (!_M_device)
> __throw_system_error(int(errc::operation_not_permitted));
> else if (_M_owns)
> __throw_system_error(int(errc::resource_deadlock_would_occur));
> else
> {
> _M_owns = _M_device->try_lock_until(__atime);
> return _M_owns;
> }
> }
>
> template<typename _Rep, typename _Period>
> bool
> try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
> {
> if (!_M_device)
> __throw_system_error(int(errc::operation_not_permitted));
> else if (_M_owns)
> __throw_system_error(int(errc::resource_deadlock_would_occur));
> else
> {
> _M_owns = _M_device->try_lock_for(__rtime);
> return _M_owns;
> }
> }
>
> void
> unlock()
> {
> if (!_M_owns)
> __throw_system_error(int(errc::operation_not_permitted));
> else if (_M_device)
> {
> _M_device->unlock();
> _M_owns = false;
> }
> }
>
> void
> swap(unique_lock& __u) noexcept
> {
> std::swap(_M_device, __u._M_device);
> std::swap(_M_owns, __u._M_owns);
> }
>
> mutex_type*
> release() noexcept
> {
> mutex_type* __ret = _M_device;
> _M_device = 0;
> _M_owns = false;
> return __ret;
> }
>
> bool
> owns_lock() const noexcept
> { return _M_owns; }
>
> explicit operator bool() const noexcept
> { return owns_lock(); }
>
> mutex_type*
> mutex() const noexcept
> { return _M_device; }
>
> private:
> mutex_type* _M_device;
> bool _M_owns;
> };
>
>
> template<typename _Mutex>
> inline void
> swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
> { __x.swap(__y); }
>
>
>
>}
># 44 "/usr/include/c++/8/mutex" 2 3
># 54 "/usr/include/c++/8/mutex" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 66 "/usr/include/c++/8/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;
># 90 "/usr/include/c++/8/mutex" 3
> };
>
>
> class recursive_mutex : private __recursive_mutex_base
> {
> public:
> typedef __native_type* native_handle_type;
>
> recursive_mutex() = default;
> ~recursive_mutex() = default;
>
> recursive_mutex(const recursive_mutex&) = delete;
> recursive_mutex& operator=(const recursive_mutex&) = delete;
>
> void
> lock()
> {
> int __e = __gthread_recursive_mutex_lock(&_M_mutex);
>
>
> if (__e)
> __throw_system_error(__e);
> }
>
> bool
> try_lock() noexcept
> {
>
> return !__gthread_recursive_mutex_trylock(&_M_mutex);
> }
>
> void
> unlock()
> {
>
> __gthread_recursive_mutex_unlock(&_M_mutex);
> }
>
> native_handle_type
> native_handle() noexcept
> { return &_M_mutex; }
> };
>
>
> template<typename _Derived>
> class __timed_mutex_impl
> {
> protected:
> typedef chrono::high_resolution_clock __clock_t;
>
> template<typename _Rep, typename _Period>
> bool
> _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
> {
> using chrono::steady_clock;
> auto __rt = chrono::duration_cast<steady_clock::duration>(__rtime);
> if (ratio_greater<steady_clock::period, _Period>())
> ++__rt;
> return _M_try_lock_until(steady_clock::now() + __rt);
> }
>
> template<typename _Duration>
> bool
> _M_try_lock_until(const chrono::time_point<__clock_t,
> _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 _Clock, typename _Duration>
> bool
> _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
> {
> auto __rtime = __atime - _Clock::now();
> return _M_try_lock_until(__clock_t::now() + __rtime);
> }
> };
>
>
> class timed_mutex
> : private __mutex_base, public __timed_mutex_impl<timed_mutex>
> {
> public:
> typedef __native_type* native_handle_type;
>
> timed_mutex() = default;
> ~timed_mutex() = default;
>
> timed_mutex(const timed_mutex&) = delete;
> timed_mutex& operator=(const timed_mutex&) = delete;
>
> void
> lock()
> {
> int __e = __gthread_mutex_lock(&_M_mutex);
>
>
> if (__e)
> __throw_system_error(__e);
> }
>
> bool
> try_lock() noexcept
> {
>
> return !__gthread_mutex_trylock(&_M_mutex);
> }
>
> template <class _Rep, class _Period>
> bool
> try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
> { return _M_try_lock_for(__rtime); }
>
> template <class _Clock, class _Duration>
> bool
> try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
> { return _M_try_lock_until(__atime); }
>
> void
> unlock()
> {
>
> __gthread_mutex_unlock(&_M_mutex);
> }
>
> native_handle_type
> native_handle() noexcept
> { return &_M_mutex; }
>
> private:
> friend class __timed_mutex_impl<timed_mutex>;
>
> bool
> _M_timedlock(const __gthread_time_t& __ts)
> { return !__gthread_mutex_timedlock(&_M_mutex, &__ts); }
> };
>
>
> class recursive_timed_mutex
> : private __recursive_mutex_base,
> public __timed_mutex_impl<recursive_timed_mutex>
> {
> public:
> typedef __native_type* native_handle_type;
>
> recursive_timed_mutex() = default;
> ~recursive_timed_mutex() = default;
>
> recursive_timed_mutex(const recursive_timed_mutex&) = delete;
> recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
>
> void
> lock()
> {
> int __e = __gthread_recursive_mutex_lock(&_M_mutex);
>
>
> if (__e)
> __throw_system_error(__e);
> }
>
> bool
> try_lock() noexcept
> {
>
> return !__gthread_recursive_mutex_trylock(&_M_mutex);
> }
>
> template <class _Rep, class _Period>
> bool
> try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
> { return _M_try_lock_for(__rtime); }
>
> template <class _Clock, class _Duration>
> bool
> try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime)
> { return _M_try_lock_until(__atime); }
>
> void
> unlock()
> {
>
> __gthread_recursive_mutex_unlock(&_M_mutex);
> }
>
> native_handle_type
> native_handle() noexcept
> { return &_M_mutex; }
>
> private:
> friend class __timed_mutex_impl<recursive_timed_mutex>;
>
> bool
> _M_timedlock(const __gthread_time_t& __ts)
> { return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); }
> };
># 467 "/usr/include/c++/8/mutex" 3
> template<typename _Lock>
> inline unique_lock<_Lock>
> __try_to_lock(_Lock& __l)
> { return unique_lock<_Lock>{__l, try_to_lock}; }
>
> template<int _Idx, bool _Continue = true>
> struct __try_lock_impl
> {
> template<typename... _Lock>
> static void
> __do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
> {
> __idx = _Idx;
> auto __lock = std::__try_to_lock(std::get<_Idx>(__locks));
> if (__lock.owns_lock())
> {
> constexpr bool __cont = _Idx + 2 < sizeof...(_Lock);
> using __try_locker = __try_lock_impl<_Idx + 1, __cont>;
> __try_locker::__do_try_lock(__locks, __idx);
> if (__idx == -1)
> __lock.release();
> }
> }
> };
>
> template<int _Idx>
> struct __try_lock_impl<_Idx, false>
> {
> template<typename... _Lock>
> static void
> __do_try_lock(tuple<_Lock&...>& __locks, int& __idx)
> {
> __idx = _Idx;
> auto __lock = std::__try_to_lock(std::get<_Idx>(__locks));
> if (__lock.owns_lock())
> {
> __idx = -1;
> __lock.release();
> }
> }
> };
># 519 "/usr/include/c++/8/mutex" 3
> template<typename _Lock1, typename _Lock2, typename... _Lock3>
> int
> try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3)
> {
> int __idx;
> auto __locks = std::tie(__l1, __l2, __l3...);
> __try_lock_impl<0>::__do_try_lock(__locks, __idx);
> return __idx;
> }
># 540 "/usr/include/c++/8/mutex" 3
> template<typename _L1, typename _L2, typename... _L3>
> void
> lock(_L1& __l1, _L2& __l2, _L3&... __l3)
> {
> while (true)
> {
> using __try_locker = __try_lock_impl<0, sizeof...(_L3) != 0>;
> unique_lock<_L1> __first(__l1);
> int __idx;
> auto __locks = std::tie(__l2, __l3...);
> __try_locker::__do_try_lock(__locks, __idx);
> if (__idx == -1)
> {
> __first.release();
> return;
> }
> }
> }
># 566 "/usr/include/c++/8/mutex" 3
> template<typename... _MutexTypes>
> class scoped_lock
> {
> public:
> explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...))
> { std::lock(__m...); }
>
> explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept
> : _M_devices(std::tie(__m...))
> { }
>
> ~scoped_lock()
> {
> std::apply([](_MutexTypes&... __m) {
> char __i[] __attribute__((__unused__)) = { (__m.unlock(), 0)... };
> }, _M_devices);
> }
>
> scoped_lock(const scoped_lock&) = delete;
> scoped_lock& operator=(const scoped_lock&) = delete;
>
> private:
> tuple<_MutexTypes&...> _M_devices;
> };
>
> template<>
> class scoped_lock<>
> {
> public:
> explicit scoped_lock() = default;
> explicit scoped_lock(adopt_lock_t) noexcept { }
> ~scoped_lock() = default;
>
> scoped_lock(const scoped_lock&) = delete;
> scoped_lock& operator=(const scoped_lock&) = delete;
> };
>
> template<typename _Mutex>
> class scoped_lock<_Mutex>
> {
> public:
> using mutex_type = _Mutex;
>
> explicit scoped_lock(mutex_type& __m) : _M_device(__m)
> { _M_device.lock(); }
>
> explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept
> : _M_device(__m)
> { }
>
> ~scoped_lock()
> { _M_device.unlock(); }
>
> scoped_lock(const scoped_lock&) = delete;
> scoped_lock& operator=(const scoped_lock&) = delete;
>
> private:
> mutex_type& _M_device;
> };
>
>
>
>
> struct once_flag
> {
> private:
> typedef __gthread_once_t __native_type;
> __native_type _M_once = 0;
>
> public:
>
> constexpr once_flag() noexcept = default;
>
>
> once_flag(const once_flag&) = delete;
>
> once_flag& operator=(const once_flag&) = delete;
>
> template<typename _Callable, typename... _Args>
> friend void
> call_once(once_flag& __once, _Callable&& __f, _Args&&... __args);
> };
>
>
> extern __thread void* __once_callable;
> extern __thread void (*__once_call)();
># 662 "/usr/include/c++/8/mutex" 3
> extern "C" void __once_proxy(void);
>
>
> template<typename _Callable, typename... _Args>
> void
> call_once(once_flag& __once, _Callable&& __f, _Args&&... __args)
> {
>
>
> auto __callable = [&] {
> std::__invoke(std::forward<_Callable>(__f),
> std::forward<_Args>(__args)...);
> };
>
> __once_callable = std::__addressof(__callable);
> __once_call = []{ (*(decltype(__callable)*)__once_callable)(); };
>
>
>
>
>
>
> int __e = __gthread_once(&__once._M_once, &__once_proxy);
># 697 "/usr/include/c++/8/mutex" 3
> if (__e)
> __throw_system_error(__e);
> }
>
>
>
>
>}
># 39 "/usr/include/c++/8/future" 2 3
># 1 "/usr/include/c++/8/thread" 1 3
># 32 "/usr/include/c++/8/thread" 3
> 
># 33 "/usr/include/c++/8/thread" 3
># 41 "/usr/include/c++/8/thread" 3
># 1 "/usr/include/c++/8/cerrno" 1 3
># 39 "/usr/include/c++/8/cerrno" 3
> 
># 40 "/usr/include/c++/8/cerrno" 3
># 42 "/usr/include/c++/8/thread" 2 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 62 "/usr/include/c++/8/thread" 3
> class thread
> {
> public:
>
>
> struct _State
> {
> virtual ~_State();
> virtual void _M_run() = 0;
> };
> using _State_ptr = unique_ptr<_State>;
>
> typedef __gthread_t native_handle_type;
>
>
> class id
> {
> native_handle_type _M_thread;
>
> public:
> id() noexcept : _M_thread() { }
>
> explicit
> id(native_handle_type __id) : _M_thread(__id) { }
>
> private:
> friend class thread;
> friend class hash<thread::id>;
>
> friend bool
> operator==(thread::id __x, thread::id __y) noexcept;
>
> friend bool
> operator<(thread::id __x, thread::id __y) noexcept;
>
> template<class _CharT, class _Traits>
> friend basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
> };
>
> private:
> id _M_id;
>
> public:
> thread() noexcept = default;
>
>
> thread(thread&) = delete;
> thread(const thread&) = delete;
> thread(const thread&&) = delete;
>
> thread(thread&& __t) noexcept
> { swap(__t); }
>
> template<typename _Callable, typename... _Args>
> explicit
> thread(_Callable&& __f, _Args&&... __args)
> {
>
>
> auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
>
>
>
> _M_start_thread(_S_make_state(
> __make_invoker(std::forward<_Callable>(__f),
> std::forward<_Args>(__args)...)),
> __depend);
> }
>
> ~thread()
> {
> if (joinable())
> std::terminate();
> }
>
> thread& operator=(const thread&) = delete;
>
> thread& operator=(thread&& __t) noexcept
> {
> if (joinable())
> std::terminate();
> swap(__t);
> return *this;
> }
>
> void
> swap(thread& __t) noexcept
> { std::swap(_M_id, __t._M_id); }
>
> bool
> joinable() const noexcept
> { return !(_M_id == id()); }
>
> void
> join();
>
> void
> detach();
>
> thread::id
> get_id() const noexcept
> { return _M_id; }
>
>
>
> native_handle_type
> native_handle()
> { return _M_id._M_thread; }
>
>
> static unsigned int
> hardware_concurrency() noexcept;
>
> private:
> template<typename _Callable>
> struct _State_impl : public _State
> {
> _Callable _M_func;
>
> _State_impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
> { }
>
> void
> _M_run() { _M_func(); }
> };
>
> void
> _M_start_thread(_State_ptr, void (*)());
>
> template<typename _Callable>
> static _State_ptr
> _S_make_state(_Callable&& __f)
> {
> using _Impl = _State_impl<_Callable>;
> return _State_ptr{new _Impl{std::forward<_Callable>(__f)}};
> }
># 218 "/usr/include/c++/8/thread" 3
> private:
>
> template<typename _Tuple>
> struct _Invoker
> {
> _Tuple _M_t;
>
> template<size_t _Index>
> static __tuple_element_t<_Index, _Tuple>&&
> _S_declval();
>
> template<size_t... _Ind>
> auto
> _M_invoke(_Index_tuple<_Ind...>)
> noexcept(noexcept(std::__invoke(_S_declval<_Ind>()...)))
> -> decltype(std::__invoke(_S_declval<_Ind>()...))
> { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); }
>
> using _Indices
> = typename _Build_index_tuple<tuple_size<_Tuple>::value>::__type;
>
> auto
> operator()()
> noexcept(noexcept(std::declval<_Invoker&>()._M_invoke(_Indices())))
> -> decltype(std::declval<_Invoker&>()._M_invoke(_Indices()))
> { return _M_invoke(_Indices()); }
> };
>
> template<typename... _Tp>
> using __decayed_tuple = tuple<typename std::decay<_Tp>::type...>;
>
> public:
>
>
> template<typename _Callable, typename... _Args>
> static _Invoker<__decayed_tuple<_Callable, _Args...>>
> __make_invoker(_Callable&& __callable, _Args&&... __args)
> {
> return { __decayed_tuple<_Callable, _Args...>{
> std::forward<_Callable>(__callable), std::forward<_Args>(__args)...
> } };
> }
> };
>
> inline void
> swap(thread& __x, thread& __y) noexcept
> { __x.swap(__y); }
>
> inline bool
> operator==(thread::id __x, thread::id __y) noexcept
> {
>
>
>
>
> return __x._M_thread == __y._M_thread;
> }
>
> inline bool
> operator!=(thread::id __x, thread::id __y) noexcept
> { return !(__x == __y); }
>
> inline bool
> operator<(thread::id __x, thread::id __y) noexcept
> {
>
>
> return __x._M_thread < __y._M_thread;
> }
>
> inline bool
> operator<=(thread::id __x, thread::id __y) noexcept
> { return !(__y < __x); }
>
> inline bool
> operator>(thread::id __x, thread::id __y) noexcept
> { return __y < __x; }
>
> inline bool
> operator>=(thread::id __x, thread::id __y) noexcept
> { return !(__x < __y); }
>
>
>
> template<>
> struct hash<thread::id>
> : public __hash_base<size_t, thread::id>
> {
> size_t
> operator()(const thread::id& __id) const noexcept
> { return std::_Hash_impl::hash(__id._M_thread); }
> };
>
> template<class _CharT, class _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
> {
> if (__id == thread::id())
> return __out << "thread::id of a non-executing thread";
> else
> return __out << __id._M_thread;
> }
>
>
>
>
>
> namespace this_thread
> {
>
> inline thread::id
> get_id() noexcept
> {
>
>
>
>
>
> if (!__gthread_active_p())
> return thread::id(1);
>
> return thread::id(__gthread_self());
> }
>
>
> inline void
> yield() noexcept
> {
>
> __gthread_yield();
>
> }
>
> void
> __sleep_for(chrono::seconds, chrono::nanoseconds);
>
>
> template<typename _Rep, typename _Period>
> inline void
> sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
> {
> if (__rtime <= __rtime.zero())
> return;
> auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
> auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
>
> __gthread_time_t __ts =
> {
> static_cast<std::time_t>(__s.count()),
> static_cast<long>(__ns.count())
> };
> while (::nanosleep(&__ts, &__ts) == -1 && (*__errno_location ()) == 4)
> { }
>
>
>
> }
>
>
> template<typename _Clock, typename _Duration>
> inline void
> sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
> {
> auto __now = _Clock::now();
> if (_Clock::is_steady)
> {
> if (__now < __atime)
> sleep_for(__atime - __now);
> return;
> }
> while (__now < __atime)
> {
> sleep_for(__atime - __now);
> __now = _Clock::now();
> }
> }
> }
>
>
>
>
>}
># 40 "/usr/include/c++/8/future" 2 3
># 1 "/usr/include/c++/8/condition_variable" 1 3
># 32 "/usr/include/c++/8/condition_variable" 3
> 
># 33 "/usr/include/c++/8/condition_variable" 3
># 49 "/usr/include/c++/8/condition_variable" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 62 "/usr/include/c++/8/condition_variable" 3
> enum class cv_status { no_timeout, timeout };
>
>
> class condition_variable
> {
> typedef chrono::system_clock __clock_t;
> typedef __gthread_cond_t __native_type;
>
>
> __native_type _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };
>
>
>
>
> public:
> typedef __native_type* native_handle_type;
>
> condition_variable() noexcept;
> ~condition_variable() noexcept;
>
> condition_variable(const condition_variable&) = delete;
> condition_variable& operator=(const condition_variable&) = delete;
>
> void
> notify_one() noexcept;
>
> void
> notify_all() noexcept;
>
> void
> wait(unique_lock<mutex>& __lock) noexcept;
>
> template<typename _Predicate>
> void
> wait(unique_lock<mutex>& __lock, _Predicate __p)
> {
> while (!__p())
> wait(__lock);
> }
>
> template<typename _Duration>
> cv_status
> wait_until(unique_lock<mutex>& __lock,
> const chrono::time_point<__clock_t, _Duration>& __atime)
> { return __wait_until_impl(__lock, __atime); }
>
> template<typename _Clock, typename _Duration>
> cv_status
> wait_until(unique_lock<mutex>& __lock,
> const chrono::time_point<_Clock, _Duration>& __atime)
> {
>
> const typename _Clock::time_point __c_entry = _Clock::now();
> const __clock_t::time_point __s_entry = __clock_t::now();
> const auto __delta = __atime - __c_entry;
> const auto __s_atime = __s_entry + __delta;
>
> return __wait_until_impl(__lock, __s_atime);
> }
>
> 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 __clock_t::duration;
> auto __reltime = chrono::duration_cast<__dur>(__rtime);
> if (__reltime < __rtime)
> ++__reltime;
> return wait_until(__lock, __clock_t::now() + __reltime);
> }
>
> template<typename _Rep, typename _Period, typename _Predicate>
> bool
> wait_for(unique_lock<mutex>& __lock,
> const chrono::duration<_Rep, _Period>& __rtime,
> _Predicate __p)
> {
> using __dur = typename __clock_t::duration;
> auto __reltime = chrono::duration_cast<__dur>(__rtime);
> if (__reltime < __rtime)
> ++__reltime;
> return wait_until(__lock, __clock_t::now() + __reltime, std::move(__p));
> }
>
> native_handle_type
> native_handle()
> { return &_M_cond; }
>
> private:
> template<typename _Dur>
> cv_status
> __wait_until_impl(unique_lock<mutex>& __lock,
> const chrono::time_point<__clock_t, _Dur>& __atime)
> {
> auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
> auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
>
> __gthread_time_t __ts =
> {
> static_cast<std::time_t>(__s.time_since_epoch().count()),
> static_cast<long>(__ns.count())
> };
>
> __gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(),
> &__ts);
>
> return (__clock_t::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
> {
> typedef chrono::system_clock __clock_t;
> condition_variable _M_cond;
> shared_ptr<mutex> _M_mutex;
>
>
> template<typename _Lock>
> struct _Unlock
> {
> explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); }
>
> ~_Unlock() noexcept(false)
> {
> if (uncaught_exception())
> {
> try
> { _M_lock.lock(); }
> catch(const __cxxabiv1::__forced_unwind&)
> { throw; }
> catch(...)
> { }
> }
> else
> _M_lock.lock();
> }
>
> _Unlock(const _Unlock&) = delete;
> _Unlock& operator=(const _Unlock&) = delete;
>
> _Lock& _M_lock;
> };
>
> public:
> condition_variable_any() : _M_mutex(std::make_shared<mutex>()) { }
> ~condition_variable_any() = default;
>
> condition_variable_any(const condition_variable_any&) = delete;
> condition_variable_any& operator=(const condition_variable_any&) = delete;
>
> void
> notify_one() noexcept
> {
> lock_guard<mutex> __lock(*_M_mutex);
> _M_cond.notify_one();
> }
>
> void
> notify_all() noexcept
> {
> lock_guard<mutex> __lock(*_M_mutex);
> _M_cond.notify_all();
> }
>
> template<typename _Lock>
> void
> wait(_Lock& __lock)
> {
> shared_ptr<mutex> __mutex = _M_mutex;
> unique_lock<mutex> __my_lock(*__mutex);
> _Unlock<_Lock> __unlock(__lock);
>
>
> unique_lock<mutex> __my_lock2(std::move(__my_lock));
> _M_cond.wait(__my_lock2);
> }
>
>
> template<typename _Lock, typename _Predicate>
> void
> wait(_Lock& __lock, _Predicate __p)
> {
> while (!__p())
> wait(__lock);
> }
>
> template<typename _Lock, typename _Clock, typename _Duration>
> cv_status
> wait_until(_Lock& __lock,
> const chrono::time_point<_Clock, _Duration>& __atime)
> {
> shared_ptr<mutex> __mutex = _M_mutex;
> unique_lock<mutex> __my_lock(*__mutex);
> _Unlock<_Lock> __unlock(__lock);
>
>
> unique_lock<mutex> __my_lock2(std::move(__my_lock));
> return _M_cond.wait_until(__my_lock2, __atime);
> }
>
> template<typename _Lock, typename _Clock,
> typename _Duration, typename _Predicate>
> bool
> wait_until(_Lock& __lock,
> const chrono::time_point<_Clock, _Duration>& __atime,
> _Predicate __p)
> {
> while (!__p())
> if (wait_until(__lock, __atime) == cv_status::timeout)
> return __p();
> return true;
> }
>
> template<typename _Lock, typename _Rep, typename _Period>
> cv_status
> wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime)
> { return wait_until(__lock, __clock_t::now() + __rtime); }
>
> template<typename _Lock, typename _Rep,
> typename _Period, typename _Predicate>
> bool
> wait_for(_Lock& __lock,
> const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p)
> { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); }
> };
>
> }
>
>
>
>}
># 41 "/usr/include/c++/8/future" 2 3
>
>
># 1 "/usr/include/c++/8/bits/atomic_futex.h" 1 3
># 33 "/usr/include/c++/8/bits/atomic_futex.h" 3
> 
># 34 "/usr/include/c++/8/bits/atomic_futex.h" 3
># 47 "/usr/include/c++/8/bits/atomic_futex.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> struct __atomic_futex_unsigned_base
> {
>
> bool
> _M_futex_wait_until(unsigned *__addr, unsigned __val, bool __has_timeout,
> chrono::seconds __s, chrono::nanoseconds __ns);
>
>
> static void _M_futex_notify_all(unsigned* __addr);
> };
>
> template <unsigned _Waiter_bit = 0x80000000>
> class __atomic_futex_unsigned : __atomic_futex_unsigned_base
> {
> typedef chrono::system_clock __clock_t;
>
>
> atomic<unsigned> _M_data;
>
> public:
> explicit
> __atomic_futex_unsigned(unsigned __data) : _M_data(__data)
> { }
>
> inline __attribute__((__always_inline__)) unsigned
> _M_load(memory_order __mo)
> {
> return _M_data.load(__mo) & ~_Waiter_bit;
> }
>
> private:
>
>
>
>
>
> unsigned
> _M_load_and_test_until(unsigned __assumed, unsigned __operand,
> bool __equal, memory_order __mo, bool __has_timeout,
> chrono::seconds __s, chrono::nanoseconds __ns)
> {
> for (;;)
> {
>
>
>
>
>
> _M_data.fetch_or(_Waiter_bit, memory_order_relaxed);
> bool __ret = _M_futex_wait_until((unsigned*)(void*)&_M_data,
> __assumed | _Waiter_bit,
> __has_timeout, __s, __ns);
>
> __assumed = _M_load(__mo);
> if (!__ret || ((__operand == __assumed) == __equal))
> return __assumed;
>
> }
> }
>
>
>
>
>
> unsigned
> _M_load_and_test(unsigned __assumed, unsigned __operand,
> bool __equal, memory_order __mo)
> {
> return _M_load_and_test_until(__assumed, __operand, __equal, __mo,
> false, {}, {});
> }
>
>
>
>
>
>
> template<typename _Dur>
> unsigned
> _M_load_and_test_until_impl(unsigned __assumed, unsigned __operand,
> bool __equal, memory_order __mo,
> const chrono::time_point<__clock_t, _Dur>& __atime)
> {
> auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
> auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
>
> return _M_load_and_test_until(__assumed, __operand, __equal, __mo,
> true, __s.time_since_epoch(), __ns);
> }
>
> public:
>
> inline __attribute__((__always_inline__)) unsigned
> _M_load_when_not_equal(unsigned __val, memory_order __mo)
> {
> unsigned __i = _M_load(__mo);
> if ((__i & ~_Waiter_bit) != __val)
> return (__i & ~_Waiter_bit);
>
> return _M_load_and_test(__i, __val, false, __mo);
> }
>
> inline __attribute__((__always_inline__)) void
> _M_load_when_equal(unsigned __val, memory_order __mo)
> {
> unsigned __i = _M_load(__mo);
> if ((__i & ~_Waiter_bit) == __val)
> return;
>
> _M_load_and_test(__i, __val, true, __mo);
> }
>
>
> template<typename _Rep, typename _Period>
> inline __attribute__((__always_inline__)) bool
> _M_load_when_equal_for(unsigned __val, memory_order __mo,
> const chrono::duration<_Rep, _Period>& __rtime)
> {
> return _M_load_when_equal_until(__val, __mo,
> __clock_t::now() + __rtime);
> }
>
>
> template<typename _Clock, typename _Duration>
> inline __attribute__((__always_inline__)) bool
> _M_load_when_equal_until(unsigned __val, memory_order __mo,
> const chrono::time_point<_Clock, _Duration>& __atime)
> {
>
> const typename _Clock::time_point __c_entry = _Clock::now();
> const __clock_t::time_point __s_entry = __clock_t::now();
> const auto __delta = __atime - __c_entry;
> const auto __s_atime = __s_entry + __delta;
> return _M_load_when_equal_until(__val, __mo, __s_atime);
> }
>
>
> template<typename _Duration>
> inline __attribute__((__always_inline__)) bool
> _M_load_when_equal_until(unsigned __val, memory_order __mo,
> const chrono::time_point<__clock_t, _Duration>& __atime)
> {
> unsigned __i = _M_load(__mo);
> if ((__i & ~_Waiter_bit) == __val)
> return true;
>
> __i = _M_load_and_test_until_impl(__i, __val, true, __mo, __atime);
> return (__i & ~_Waiter_bit) == __val;
> }
>
> inline __attribute__((__always_inline__)) void
> _M_store_notify_all(unsigned __val, memory_order __mo)
> {
> unsigned* __futex = (unsigned *)(void *)&_M_data;
> if (_M_data.exchange(__val, __mo) & _Waiter_bit)
> _M_futex_notify_all(__futex);
> }
> };
># 287 "/usr/include/c++/8/bits/atomic_futex.h" 3
>
>}
># 44 "/usr/include/c++/8/future" 2 3
># 53 "/usr/include/c++/8/future" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 66 "/usr/include/c++/8/future" 3
> enum class future_errc
> {
> future_already_retrieved = 1,
> promise_already_satisfied,
> no_state,
> broken_promise
> };
>
>
> template<>
> struct is_error_code_enum<future_errc> : public true_type { };
>
>
> const error_category&
> future_category() noexcept;
>
>
> inline error_code
> make_error_code(future_errc __errc) noexcept
> { return error_code(static_cast<int>(__errc), future_category()); }
>
>
> inline error_condition
> make_error_condition(future_errc __errc) noexcept
> { return error_condition(static_cast<int>(__errc), future_category()); }
>
>
>
>
>
> class future_error : public logic_error
> {
> public:
> explicit
> future_error(future_errc __errc)
> : future_error(std::make_error_code(__errc))
> { }
>
> virtual ~future_error() noexcept;
>
> virtual const char*
> what() const noexcept;
>
> const error_code&
> code() const noexcept { return _M_code; }
>
> private:
> explicit
> future_error(error_code __ec)
> : logic_error("std::future_error: " + __ec.message()), _M_code(__ec)
> { }
>
> friend void __throw_future_error(int);
>
> error_code _M_code;
> };
>
>
> template<typename _Res>
> class future;
>
> template<typename _Res>
> class shared_future;
>
> template<typename _Signature>
> class packaged_task;
>
> template<typename _Res>
> class promise;
>
>
> enum class launch
> {
> async = 1,
> deferred = 2
> };
>
> constexpr launch operator&(launch __x, launch __y)
> {
> return static_cast<launch>(
> static_cast<int>(__x) & static_cast<int>(__y));
> }
>
> constexpr launch operator|(launch __x, launch __y)
> {
> return static_cast<launch>(
> static_cast<int>(__x) | static_cast<int>(__y));
> }
>
> constexpr launch operator^(launch __x, launch __y)
> {
> return static_cast<launch>(
> static_cast<int>(__x) ^ static_cast<int>(__y));
> }
>
> constexpr launch operator~(launch __x)
> { return static_cast<launch>(~static_cast<int>(__x)); }
>
> inline launch& operator&=(launch& __x, launch __y)
> { return __x = __x & __y; }
>
> inline launch& operator|=(launch& __x, launch __y)
> { return __x = __x | __y; }
>
> inline launch& operator^=(launch& __x, launch __y)
> { return __x = __x ^ __y; }
>
>
> enum class future_status
> {
> ready,
> timeout,
> deferred
> };
>
>
>
> template<typename _Fn, typename... _Args>
> using __async_result_of = typename result_of<
> typename decay<_Fn>::type(typename decay<_Args>::type...)>::type;
>
> template<typename _Fn, typename... _Args>
> future<__async_result_of<_Fn, _Args...>>
> async(launch __policy, _Fn&& __fn, _Args&&... __args);
>
> template<typename _Fn, typename... _Args>
> future<__async_result_of<_Fn, _Args...>>
> async(_Fn&& __fn, _Args&&... __args);
>
>
>
>
> struct __future_base
> {
>
> struct _Result_base
> {
> exception_ptr _M_error;
>
> _Result_base(const _Result_base&) = delete;
> _Result_base& operator=(const _Result_base&) = delete;
>
>
> virtual void _M_destroy() = 0;
>
> struct _Deleter
> {
> void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
> };
>
> protected:
> _Result_base();
> virtual ~_Result_base();
> };
>
>
> template<typename _Res>
> using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;
>
>
> template<typename _Res>
> struct _Result : _Result_base
> {
> private:
> __gnu_cxx::__aligned_buffer<_Res> _M_storage;
> bool _M_initialized;
>
> public:
> typedef _Res result_type;
>
> _Result() noexcept : _M_initialized() { }
>
> ~_Result()
> {
> if (_M_initialized)
> _M_value().~_Res();
> }
>
>
> _Res&
> _M_value() noexcept { return *_M_storage._M_ptr(); }
>
> void
> _M_set(const _Res& __res)
> {
> ::new (_M_storage._M_addr()) _Res(__res);
> _M_initialized = true;
> }
>
> void
> _M_set(_Res&& __res)
> {
> ::new (_M_storage._M_addr()) _Res(std::move(__res));
> _M_initialized = true;
> }
>
> private:
> void _M_destroy() { delete this; }
> };
>
>
> template<typename _Res, typename _Alloc>
> struct _Result_alloc final : _Result<_Res>, _Alloc
> {
> using __allocator_type = __alloc_rebind<_Alloc, _Result_alloc>;
>
> explicit
> _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
> { }
>
> private:
> void _M_destroy()
> {
> __allocator_type __a(*this);
> __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
> this->~_Result_alloc();
> }
> };
>
>
> template<typename _Res, typename _Allocator>
> static _Ptr<_Result_alloc<_Res, _Allocator>>
> _S_allocate_result(const _Allocator& __a)
> {
> using __result_type = _Result_alloc<_Res, _Allocator>;
> typename __result_type::__allocator_type __a2(__a);
> auto __guard = std::__allocate_guarded(__a2);
> __result_type* __p = ::new((void*)__guard.get()) __result_type{__a};
> __guard = nullptr;
> return _Ptr<__result_type>(__p);
> }
>
>
> template<typename _Res, typename _Tp>
> static _Ptr<_Result<_Res>>
> _S_allocate_result(const std::allocator<_Tp>& __a)
> {
> return _Ptr<_Result<_Res>>(new _Result<_Res>);
> }
>
>
>
>
> class _State_baseV2
> {
> typedef _Ptr<_Result_base> _Ptr_type;
>
> enum _Status : unsigned {
> __not_ready,
> __ready
> };
>
> _Ptr_type _M_result;
> __atomic_futex_unsigned<> _M_status;
> atomic_flag _M_retrieved = { 0 };
> once_flag _M_once;
>
> public:
> _State_baseV2() noexcept : _M_result(), _M_status(_Status::__not_ready)
> { }
> _State_baseV2(const _State_baseV2&) = delete;
> _State_baseV2& operator=(const _State_baseV2&) = delete;
> virtual ~_State_baseV2() = default;
>
> _Result_base&
> wait()
> {
>
> _M_complete_async();
>
>
> _M_status._M_load_when_equal(_Status::__ready, memory_order_acquire);
> return *_M_result;
> }
>
> template<typename _Rep, typename _Period>
> future_status
> wait_for(const chrono::duration<_Rep, _Period>& __rel)
> {
>
>
> if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
> return future_status::ready;
> if (_M_is_deferred_future())
> return future_status::deferred;
> if (_M_status._M_load_when_equal_for(_Status::__ready,
> memory_order_acquire, __rel))
> {
># 363 "/usr/include/c++/8/future" 3
> _M_complete_async();
>
> return future_status::ready;
> }
> return future_status::timeout;
> }
>
> template<typename _Clock, typename _Duration>
> future_status
> wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
> {
>
>
> if (_M_status._M_load(memory_order_acquire) == _Status::__ready)
> return future_status::ready;
> if (_M_is_deferred_future())
> return future_status::deferred;
> if (_M_status._M_load_when_equal_until(_Status::__ready,
> memory_order_acquire, __abs))
> {
>
>
>
> _M_complete_async();
>
> return future_status::ready;
> }
> return future_status::timeout;
> }
>
>
>
> void
> _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
> {
> bool __did_set = false;
>
>
> call_once(_M_once, &_State_baseV2::_M_do_set, this,
> std::__addressof(__res), std::__addressof(__did_set));
> if (__did_set)
>
> _M_status._M_store_notify_all(_Status::__ready,
> memory_order_release);
> else if (!__ignore_failure)
> __throw_future_error(int(future_errc::promise_already_satisfied));
> }
>
>
>
>
> void
> _M_set_delayed_result(function<_Ptr_type()> __res,
> weak_ptr<_State_baseV2> __self)
> {
> bool __did_set = false;
> unique_ptr<_Make_ready> __mr{new _Make_ready};
>
>
> call_once(_M_once, &_State_baseV2::_M_do_set, this,
> std::__addressof(__res), std::__addressof(__did_set));
> if (!__did_set)
> __throw_future_error(int(future_errc::promise_already_satisfied));
> __mr->_M_shared_state = std::move(__self);
> __mr->_M_set();
> __mr.release();
> }
>
>
> void
> _M_break_promise(_Ptr_type __res)
> {
> if (static_cast<bool>(__res))
> {
> __res->_M_error =
> make_exception_ptr(future_error(future_errc::broken_promise));
>
>
>
>
> _M_result.swap(__res);
>
> _M_status._M_store_notify_all(_Status::__ready,
> memory_order_release);
> }
> }
>
>
> void
> _M_set_retrieved_flag()
> {
> if (_M_retrieved.test_and_set())
> __throw_future_error(int(future_errc::future_already_retrieved));
> }
>
> template<typename _Res, typename _Arg>
> struct _Setter;
>
>
> template<typename _Res, typename _Arg>
> struct _Setter<_Res, _Arg&>
> {
>
>
> static_assert(is_same<_Res, _Arg&>::value
> || is_same<const _Res, _Arg>::value,
> "Invalid specialisation");
>
>
> typename promise<_Res>::_Ptr_type operator()() const
> {
> _M_promise->_M_storage->_M_set(*_M_arg);
> return std::move(_M_promise->_M_storage);
> }
> promise<_Res>* _M_promise;
> _Arg* _M_arg;
> };
>
>
> template<typename _Res>
> struct _Setter<_Res, _Res&&>
> {
>
> typename promise<_Res>::_Ptr_type operator()() const
> {
> _M_promise->_M_storage->_M_set(std::move(*_M_arg));
> return std::move(_M_promise->_M_storage);
> }
> promise<_Res>* _M_promise;
> _Res* _M_arg;
> };
>
>
> template<typename _Res>
> struct _Setter<_Res, void>
> {
> static_assert(is_void<_Res>::value, "Only used for promise<void>");
>
> typename promise<_Res>::_Ptr_type operator()() const
> { return std::move(_M_promise->_M_storage); }
>
> promise<_Res>* _M_promise;
> };
>
> struct __exception_ptr_tag { };
>
>
> template<typename _Res>
> struct _Setter<_Res, __exception_ptr_tag>
> {
>
> typename promise<_Res>::_Ptr_type operator()() const
> {
> _M_promise->_M_storage->_M_error = *_M_ex;
> return std::move(_M_promise->_M_storage);
> }
>
> promise<_Res>* _M_promise;
> exception_ptr* _M_ex;
> };
>
> template<typename _Res, typename _Arg>
> static _Setter<_Res, _Arg&&>
> __setter(promise<_Res>* __prom, _Arg&& __arg)
> {
> _S_check(__prom->_M_future);
> return _Setter<_Res, _Arg&&>{ __prom, std::__addressof(__arg) };
> }
>
> template<typename _Res>
> static _Setter<_Res, __exception_ptr_tag>
> __setter(exception_ptr& __ex, promise<_Res>* __prom)
> {
> _S_check(__prom->_M_future);
> return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex };
> }
>
> template<typename _Res>
> static _Setter<_Res, void>
> __setter(promise<_Res>* __prom)
> {
> _S_check(__prom->_M_future);
> return _Setter<_Res, void>{ __prom };
> }
>
> template<typename _Tp>
> static void
> _S_check(const shared_ptr<_Tp>& __p)
> {
> if (!static_cast<bool>(__p))
> __throw_future_error((int)future_errc::no_state);
> }
>
> private:
>
> void
> _M_do_set(function<_Ptr_type()>* __f, bool* __did_set)
> {
> _Ptr_type __res = (*__f)();
>
>
>
> *__did_set = true;
> _M_result.swap(__res);
> }
>
>
> virtual void _M_complete_async() { }
>
>
> virtual bool _M_is_deferred_future() const { return false; }
>
> struct _Make_ready final : __at_thread_exit_elt
> {
> weak_ptr<_State_baseV2> _M_shared_state;
> static void _S_run(void*);
> void _M_set();
> };
> };
>
>
>
>
>
> using _State_base = _State_baseV2;
> class _Async_state_commonV2;
>
>
> template<typename _BoundFn,
> typename _Res = decltype(std::declval<_BoundFn&>()())>
> class _Deferred_state;
>
> template<typename _BoundFn,
> typename _Res = decltype(std::declval<_BoundFn&>()())>
> class _Async_state_impl;
>
> template<typename _Signature>
> class _Task_state_base;
>
> template<typename _Fn, typename _Alloc, typename _Signature>
> class _Task_state;
>
> template<typename _BoundFn>
> static std::shared_ptr<_State_base>
> _S_make_deferred_state(_BoundFn&& __fn);
>
> template<typename _BoundFn>
> static std::shared_ptr<_State_base>
> _S_make_async_state(_BoundFn&& __fn);
>
> template<typename _Res_ptr, typename _Fn,
> typename _Res = typename _Res_ptr::element_type::result_type>
> struct _Task_setter;
>
> template<typename _Res_ptr, typename _BoundFn>
> static _Task_setter<_Res_ptr, _BoundFn>
> _S_task_setter(_Res_ptr& __ptr, _BoundFn& __call)
> {
> return { std::__addressof(__ptr), std::__addressof(__call) };
> }
> };
>
>
> template<typename _Res>
> struct __future_base::_Result<_Res&> : __future_base::_Result_base
> {
> typedef _Res& result_type;
>
> _Result() noexcept : _M_value_ptr() { }
>
> void
> _M_set(_Res& __res) noexcept
> { _M_value_ptr = std::addressof(__res); }
>
> _Res& _M_get() noexcept { return *_M_value_ptr; }
>
> private:
> _Res* _M_value_ptr;
>
> void _M_destroy() { delete this; }
> };
>
>
> template<>
> struct __future_base::_Result<void> : __future_base::_Result_base
> {
> typedef void result_type;
>
> private:
> void _M_destroy() { delete this; }
> };
>
>
>
>
> template<typename _Res, typename _Arg>
> struct __is_location_invariant
> <__future_base::_State_base::_Setter<_Res, _Arg>>
> : true_type { };
>
>
> template<typename _Res_ptr, typename _Fn, typename _Res>
> struct __is_location_invariant
> <__future_base::_Task_setter<_Res_ptr, _Fn, _Res>>
> : true_type { };
>
>
> template<typename _Res>
> class __basic_future : public __future_base
> {
> protected:
> typedef shared_ptr<_State_base> __state_type;
> typedef __future_base::_Result<_Res>& __result_type;
>
> private:
> __state_type _M_state;
>
> public:
>
> __basic_future(const __basic_future&) = delete;
> __basic_future& operator=(const __basic_future&) = delete;
>
> bool
> valid() const noexcept { return static_cast<bool>(_M_state); }
>
> void
> wait() const
> {
> _State_base::_S_check(_M_state);
> _M_state->wait();
> }
>
> template<typename _Rep, typename _Period>
> future_status
> wait_for(const chrono::duration<_Rep, _Period>& __rel) const
> {
> _State_base::_S_check(_M_state);
> return _M_state->wait_for(__rel);
> }
>
> template<typename _Clock, typename _Duration>
> future_status
> wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
> {
> _State_base::_S_check(_M_state);
> return _M_state->wait_until(__abs);
> }
>
> protected:
>
> __result_type
> _M_get_result() const
> {
> _State_base::_S_check(_M_state);
> _Result_base& __res = _M_state->wait();
> if (!(__res._M_error == 0))
> rethrow_exception(__res._M_error);
> return static_cast<__result_type>(__res);
> }
>
> void _M_swap(__basic_future& __that) noexcept
> {
> _M_state.swap(__that._M_state);
> }
>
>
> explicit
> __basic_future(const __state_type& __state) : _M_state(__state)
> {
> _State_base::_S_check(_M_state);
> _M_state->_M_set_retrieved_flag();
> }
>
>
> explicit
> __basic_future(const shared_future<_Res>&) noexcept;
>
>
> explicit
> __basic_future(shared_future<_Res>&&) noexcept;
>
>
> explicit
> __basic_future(future<_Res>&&) noexcept;
>
> constexpr __basic_future() noexcept : _M_state() { }
>
> struct _Reset
> {
> explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { }
> ~_Reset() { _M_fut._M_state.reset(); }
> __basic_future& _M_fut;
> };
> };
>
>
>
> template<typename _Res>
> class future : public __basic_future<_Res>
> {
> friend class promise<_Res>;
> template<typename> friend class packaged_task;
> template<typename _Fn, typename... _Args>
> friend future<__async_result_of<_Fn, _Args...>>
> async(launch, _Fn&&, _Args&&...);
>
> typedef __basic_future<_Res> _Base_type;
> typedef typename _Base_type::__state_type __state_type;
>
> explicit
> future(const __state_type& __state) : _Base_type(__state) { }
>
> public:
> constexpr future() noexcept : _Base_type() { }
>
>
> future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
>
>
> future(const future&) = delete;
> future& operator=(const future&) = delete;
>
> future& operator=(future&& __fut) noexcept
> {
> future(std::move(__fut))._M_swap(*this);
> return *this;
> }
>
>
> _Res
> get()
> {
> typename _Base_type::_Reset __reset(*this);
> return std::move(this->_M_get_result()._M_value());
> }
>
> shared_future<_Res> share() noexcept;
> };
>
>
> template<typename _Res>
> class future<_Res&> : public __basic_future<_Res&>
> {
> friend class promise<_Res&>;
> template<typename> friend class packaged_task;
> template<typename _Fn, typename... _Args>
> friend future<__async_result_of<_Fn, _Args...>>
> async(launch, _Fn&&, _Args&&...);
>
> typedef __basic_future<_Res&> _Base_type;
> typedef typename _Base_type::__state_type __state_type;
>
> explicit
> future(const __state_type& __state) : _Base_type(__state) { }
>
> public:
> constexpr future() noexcept : _Base_type() { }
>
>
> future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
>
>
> future(const future&) = delete;
> future& operator=(const future&) = delete;
>
> future& operator=(future&& __fut) noexcept
> {
> future(std::move(__fut))._M_swap(*this);
> return *this;
> }
>
>
> _Res&
> get()
> {
> typename _Base_type::_Reset __reset(*this);
> return this->_M_get_result()._M_get();
> }
>
> shared_future<_Res&> share() noexcept;
> };
>
>
> template<>
> class future<void> : public __basic_future<void>
> {
> friend class promise<void>;
> template<typename> friend class packaged_task;
> template<typename _Fn, typename... _Args>
> friend future<__async_result_of<_Fn, _Args...>>
> async(launch, _Fn&&, _Args&&...);
>
> typedef __basic_future<void> _Base_type;
> typedef typename _Base_type::__state_type __state_type;
>
> explicit
> future(const __state_type& __state) : _Base_type(__state) { }
>
> public:
> constexpr future() noexcept : _Base_type() { }
>
>
> future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
>
>
> future(const future&) = delete;
> future& operator=(const future&) = delete;
>
> future& operator=(future&& __fut) noexcept
> {
> future(std::move(__fut))._M_swap(*this);
> return *this;
> }
>
>
> void
> get()
> {
> typename _Base_type::_Reset __reset(*this);
> this->_M_get_result();
> }
>
> shared_future<void> share() noexcept;
> };
>
>
>
> template<typename _Res>
> class shared_future : public __basic_future<_Res>
> {
> typedef __basic_future<_Res> _Base_type;
>
> public:
> constexpr shared_future() noexcept : _Base_type() { }
>
>
> shared_future(const shared_future& __sf) noexcept : _Base_type(__sf) { }
>
>
> shared_future(future<_Res>&& __uf) noexcept
> : _Base_type(std::move(__uf))
> { }
>
>
> shared_future(shared_future&& __sf) noexcept
> : _Base_type(std::move(__sf))
> { }
>
> shared_future& operator=(const shared_future& __sf) noexcept
> {
> shared_future(__sf)._M_swap(*this);
> return *this;
> }
>
> shared_future& operator=(shared_future&& __sf) noexcept
> {
> shared_future(std::move(__sf))._M_swap(*this);
> return *this;
> }
>
>
> const _Res&
> get() const { return this->_M_get_result()._M_value(); }
> };
>
>
> template<typename _Res>
> class shared_future<_Res&> : public __basic_future<_Res&>
> {
> typedef __basic_future<_Res&> _Base_type;
>
> public:
> constexpr shared_future() noexcept : _Base_type() { }
>
>
> shared_future(const shared_future& __sf) : _Base_type(__sf) { }
>
>
> shared_future(future<_Res&>&& __uf) noexcept
> : _Base_type(std::move(__uf))
> { }
>
>
> shared_future(shared_future&& __sf) noexcept
> : _Base_type(std::move(__sf))
> { }
>
> shared_future& operator=(const shared_future& __sf)
> {
> shared_future(__sf)._M_swap(*this);
> return *this;
> }
>
> shared_future& operator=(shared_future&& __sf) noexcept
> {
> shared_future(std::move(__sf))._M_swap(*this);
> return *this;
> }
>
>
> _Res&
> get() const { return this->_M_get_result()._M_get(); }
> };
>
>
> template<>
> class shared_future<void> : public __basic_future<void>
> {
> typedef __basic_future<void> _Base_type;
>
> public:
> constexpr shared_future() noexcept : _Base_type() { }
>
>
> shared_future(const shared_future& __sf) : _Base_type(__sf) { }
>
>
> shared_future(future<void>&& __uf) noexcept
> : _Base_type(std::move(__uf))
> { }
>
>
> shared_future(shared_future&& __sf) noexcept
> : _Base_type(std::move(__sf))
> { }
>
> shared_future& operator=(const shared_future& __sf)
> {
> shared_future(__sf)._M_swap(*this);
> return *this;
> }
>
> shared_future& operator=(shared_future&& __sf) noexcept
> {
> shared_future(std::move(__sf))._M_swap(*this);
> return *this;
> }
>
>
> void
> get() const { this->_M_get_result(); }
> };
>
>
> template<typename _Res>
> inline __basic_future<_Res>::
> __basic_future(const shared_future<_Res>& __sf) noexcept
> : _M_state(__sf._M_state)
> { }
>
> template<typename _Res>
> inline __basic_future<_Res>::
> __basic_future(shared_future<_Res>&& __sf) noexcept
> : _M_state(std::move(__sf._M_state))
> { }
>
> template<typename _Res>
> inline __basic_future<_Res>::
> __basic_future(future<_Res>&& __uf) noexcept
> : _M_state(std::move(__uf._M_state))
> { }
>
>
>
> template<typename _Res>
> inline shared_future<_Res>
> future<_Res>::share() noexcept
> { return shared_future<_Res>(std::move(*this)); }
>
> template<typename _Res>
> inline shared_future<_Res&>
> future<_Res&>::share() noexcept
> { return shared_future<_Res&>(std::move(*this)); }
>
> inline shared_future<void>
> future<void>::share() noexcept
> { return shared_future<void>(std::move(*this)); }
>
>
> template<typename _Res>
> class promise
> {
> typedef __future_base::_State_base _State;
> typedef __future_base::_Result<_Res> _Res_type;
> typedef __future_base::_Ptr<_Res_type> _Ptr_type;
> template<typename, typename> friend class _State::_Setter;
> friend _State;
>
> shared_ptr<_State> _M_future;
> _Ptr_type _M_storage;
>
> public:
> promise()
> : _M_future(std::make_shared<_State>()),
> _M_storage(new _Res_type())
> { }
>
> promise(promise&& __rhs) noexcept
> : _M_future(std::move(__rhs._M_future)),
> _M_storage(std::move(__rhs._M_storage))
> { }
>
> template<typename _Allocator>
> promise(allocator_arg_t, const _Allocator& __a)
> : _M_future(std::allocate_shared<_State>(__a)),
> _M_storage(__future_base::_S_allocate_result<_Res>(__a))
> { }
>
> template<typename _Allocator>
> promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
> : _M_future(std::move(__rhs._M_future)),
> _M_storage(std::move(__rhs._M_storage))
> { }
>
> promise(const promise&) = delete;
>
> ~promise()
> {
> if (static_cast<bool>(_M_future) && !_M_future.unique())
> _M_future->_M_break_promise(std::move(_M_storage));
> }
>
>
> promise&
> operator=(promise&& __rhs) noexcept
> {
> promise(std::move(__rhs)).swap(*this);
> return *this;
> }
>
> promise& operator=(const promise&) = delete;
>
> void
> swap(promise& __rhs) noexcept
> {
> _M_future.swap(__rhs._M_future);
> _M_storage.swap(__rhs._M_storage);
> }
>
>
> future<_Res>
> get_future()
> { return future<_Res>(_M_future); }
>
>
> void
> set_value(const _Res& __r)
> { _M_future->_M_set_result(_State::__setter(this, __r)); }
>
> void
> set_value(_Res&& __r)
> { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); }
>
> void
> set_exception(exception_ptr __p)
> { _M_future->_M_set_result(_State::__setter(__p, this)); }
>
> void
> set_value_at_thread_exit(const _Res& __r)
> {
> _M_future->_M_set_delayed_result(_State::__setter(this, __r),
> _M_future);
> }
>
> void
> set_value_at_thread_exit(_Res&& __r)
> {
> _M_future->_M_set_delayed_result(
> _State::__setter(this, std::move(__r)), _M_future);
> }
>
> void
> set_exception_at_thread_exit(exception_ptr __p)
> {
> _M_future->_M_set_delayed_result(_State::__setter(__p, this),
> _M_future);
> }
> };
>
> template<typename _Res>
> inline void
> swap(promise<_Res>& __x, promise<_Res>& __y) noexcept
> { __x.swap(__y); }
>
> template<typename _Res, typename _Alloc>
> struct uses_allocator<promise<_Res>, _Alloc>
> : public true_type { };
>
>
>
> template<typename _Res>
> class promise<_Res&>
> {
> typedef __future_base::_State_base _State;
> typedef __future_base::_Result<_Res&> _Res_type;
> typedef __future_base::_Ptr<_Res_type> _Ptr_type;
> template<typename, typename> friend class _State::_Setter;
> friend _State;
>
> shared_ptr<_State> _M_future;
> _Ptr_type _M_storage;
>
> public:
> promise()
> : _M_future(std::make_shared<_State>()),
> _M_storage(new _Res_type())
> { }
>
> promise(promise&& __rhs) noexcept
> : _M_future(std::move(__rhs._M_future)),
> _M_storage(std::move(__rhs._M_storage))
> { }
>
> template<typename _Allocator>
> promise(allocator_arg_t, const _Allocator& __a)
> : _M_future(std::allocate_shared<_State>(__a)),
> _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
> { }
>
> template<typename _Allocator>
> promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
> : _M_future(std::move(__rhs._M_future)),
> _M_storage(std::move(__rhs._M_storage))
> { }
>
> promise(const promise&) = delete;
>
> ~promise()
> {
> if (static_cast<bool>(_M_future) && !_M_future.unique())
> _M_future->_M_break_promise(std::move(_M_storage));
> }
>
>
> promise&
> operator=(promise&& __rhs) noexcept
> {
> promise(std::move(__rhs)).swap(*this);
> return *this;
> }
>
> promise& operator=(const promise&) = delete;
>
> void
> swap(promise& __rhs) noexcept
> {
> _M_future.swap(__rhs._M_future);
> _M_storage.swap(__rhs._M_storage);
> }
>
>
> future<_Res&>
> get_future()
> { return future<_Res&>(_M_future); }
>
>
> void
> set_value(_Res& __r)
> { _M_future->_M_set_result(_State::__setter(this, __r)); }
>
> void
> set_exception(exception_ptr __p)
> { _M_future->_M_set_result(_State::__setter(__p, this)); }
>
> void
> set_value_at_thread_exit(_Res& __r)
> {
> _M_future->_M_set_delayed_result(_State::__setter(this, __r),
> _M_future);
> }
>
> void
> set_exception_at_thread_exit(exception_ptr __p)
> {
> _M_future->_M_set_delayed_result(_State::__setter(__p, this),
> _M_future);
> }
> };
>
>
> template<>
> class promise<void>
> {
> typedef __future_base::_State_base _State;
> typedef __future_base::_Result<void> _Res_type;
> typedef __future_base::_Ptr<_Res_type> _Ptr_type;
> template<typename, typename> friend class _State::_Setter;
> friend _State;
>
> shared_ptr<_State> _M_future;
> _Ptr_type _M_storage;
>
> public:
> promise()
> : _M_future(std::make_shared<_State>()),
> _M_storage(new _Res_type())
> { }
>
> promise(promise&& __rhs) noexcept
> : _M_future(std::move(__rhs._M_future)),
> _M_storage(std::move(__rhs._M_storage))
> { }
>
> template<typename _Allocator>
> promise(allocator_arg_t, const _Allocator& __a)
> : _M_future(std::allocate_shared<_State>(__a)),
> _M_storage(__future_base::_S_allocate_result<void>(__a))
> { }
>
>
>
> template<typename _Allocator>
> promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
> : _M_future(std::move(__rhs._M_future)),
> _M_storage(std::move(__rhs._M_storage))
> { }
>
> promise(const promise&) = delete;
>
> ~promise()
> {
> if (static_cast<bool>(_M_future) && !_M_future.unique())
> _M_future->_M_break_promise(std::move(_M_storage));
> }
>
>
> promise&
> operator=(promise&& __rhs) noexcept
> {
> promise(std::move(__rhs)).swap(*this);
> return *this;
> }
>
> promise& operator=(const promise&) = delete;
>
> void
> swap(promise& __rhs) noexcept
> {
> _M_future.swap(__rhs._M_future);
> _M_storage.swap(__rhs._M_storage);
> }
>
>
> future<void>
> get_future()
> { return future<void>(_M_future); }
>
>
> void
> set_value()
> { _M_future->_M_set_result(_State::__setter(this)); }
>
> void
> set_exception(exception_ptr __p)
> { _M_future->_M_set_result(_State::__setter(__p, this)); }
>
> void
> set_value_at_thread_exit()
> { _M_future->_M_set_delayed_result(_State::__setter(this), _M_future); }
>
> void
> set_exception_at_thread_exit(exception_ptr __p)
> {
> _M_future->_M_set_delayed_result(_State::__setter(__p, this),
> _M_future);
> }
> };
>
> template<typename _Ptr_type, typename _Fn, typename _Res>
> struct __future_base::_Task_setter
> {
>
> _Ptr_type operator()() const
> {
> try
> {
> (*_M_result)->_M_set((*_M_fn)());
> }
> catch(const __cxxabiv1::__forced_unwind&)
> {
> throw;
> }
> catch(...)
> {
> (*_M_result)->_M_error = current_exception();
> }
> return std::move(*_M_result);
> }
> _Ptr_type* _M_result;
> _Fn* _M_fn;
> };
>
> template<typename _Ptr_type, typename _Fn>
> struct __future_base::_Task_setter<_Ptr_type, _Fn, void>
> {
> _Ptr_type operator()() const
> {
> try
> {
> (*_M_fn)();
> }
> catch(const __cxxabiv1::__forced_unwind&)
> {
> throw;
> }
> catch(...)
> {
> (*_M_result)->_M_error = current_exception();
> }
> return std::move(*_M_result);
> }
> _Ptr_type* _M_result;
> _Fn* _M_fn;
> };
>
>
> template<typename _Res, typename... _Args>
> struct __future_base::_Task_state_base<_Res(_Args...)>
> : __future_base::_State_base
> {
> typedef _Res _Res_type;
>
> template<typename _Alloc>
> _Task_state_base(const _Alloc& __a)
> : _M_result(_S_allocate_result<_Res>(__a))
> { }
>
>
> virtual void
> _M_run(_Args&&... __args) = 0;
>
>
> virtual void
> _M_run_delayed(_Args&&... __args, weak_ptr<_State_base>) = 0;
>
> virtual shared_ptr<_Task_state_base>
> _M_reset() = 0;
>
> typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
> _Ptr_type _M_result;
> };
>
>
> template<typename _Fn, typename _Alloc, typename _Res, typename... _Args>
> struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final
> : __future_base::_Task_state_base<_Res(_Args...)>
> {
> template<typename _Fn2>
> _Task_state(_Fn2&& __fn, const _Alloc& __a)
> : _Task_state_base<_Res(_Args...)>(__a),
> _M_impl(std::forward<_Fn2>(__fn), __a)
> { }
>
> private:
> virtual void
> _M_run(_Args&&... __args)
> {
> auto __boundfn = [&] () -> typename result_of<_Fn&(_Args&&...)>::type {
> return std::__invoke(_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 = [&] () -> typename result_of<_Fn&(_Args&&...)>::type {
> return std::__invoke(_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>
> static shared_ptr<__future_base::_Task_state_base<_Signature>>
> __create_task_state(_Fn&& __fn, const _Alloc& __a)
> {
> 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 _Task, typename _Fn, bool
> = is_same<_Task, typename decay<_Fn>::type>::value>
> struct __constrain_pkgdtask
> { typedef void __type; };
>
> template<typename _Task, typename _Fn>
> struct __constrain_pkgdtask<_Task, _Fn, true>
> { };
>
>
> 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;
>
> public:
>
> packaged_task() noexcept { }
>
>
>
> template<typename _Allocator>
> packaged_task(allocator_arg_t, const _Allocator& __a) noexcept
> { }
>
> template<typename _Fn, typename = typename
> __constrain_pkgdtask<packaged_task, _Fn>::__type>
> explicit
> packaged_task(_Fn&& __fn)
> : packaged_task(allocator_arg, std::allocator<int>(),
> std::forward<_Fn>(__fn))
> { }
>
>
>
>
> template<typename _Fn, typename _Alloc, typename = typename
> __constrain_pkgdtask<packaged_task, _Fn>::__type>
> packaged_task(allocator_arg_t, const _Alloc& __a, _Fn&& __fn)
> : _M_state(__create_task_state<_Res(_ArgTypes...)>(
> std::forward<_Fn>(__fn), __a))
> { }
>
> ~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;
>
> template<typename _Allocator>
> packaged_task(allocator_arg_t, const _Allocator&,
> const packaged_task&) = delete;
>
>
> packaged_task(packaged_task&& __other) noexcept
> { this->swap(__other); }
>
> template<typename _Allocator>
> packaged_task(allocator_arg_t, const _Allocator&,
> packaged_task&& __other) noexcept
> { this->swap(__other); }
>
> packaged_task& operator=(packaged_task&& __other) noexcept
> {
> packaged_task(std::move(__other)).swap(*this);
> return *this;
> }
>
> void
> swap(packaged_task& __other) noexcept
> { _M_state.swap(__other._M_state); }
>
> bool
> valid() const noexcept
> { return static_cast<bool>(_M_state); }
>
>
> future<_Res>
> get_future()
> { return future<_Res>(_M_state); }
>
>
> void
> operator()(_ArgTypes... __args)
> {
> __future_base::_State_base::_S_check(_M_state);
> _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
> }
>
> void
> make_ready_at_thread_exit(_ArgTypes... __args)
> {
> __future_base::_State_base::_S_check(_M_state);
> _M_state->_M_run_delayed(std::forward<_ArgTypes>(__args)..., _M_state);
> }
>
> void
> reset()
> {
> __future_base::_State_base::_S_check(_M_state);
> packaged_task __tmp;
> __tmp._M_state = _M_state;
> _M_state = _M_state->_M_reset();
> }
> };
>
>
> template<typename _Res, typename... _ArgTypes>
> inline void
> swap(packaged_task<_Res(_ArgTypes...)>& __x,
> packaged_task<_Res(_ArgTypes...)>& __y) noexcept
> { __x.swap(__y); }
>
> template<typename _Res, typename _Alloc>
> struct uses_allocator<packaged_task<_Res>, _Alloc>
> : public true_type { };
>
>
>
>
> template<typename _BoundFn, typename _Res>
> class __future_base::_Deferred_state final
> : public __future_base::_State_base
> {
> public:
> explicit
> _Deferred_state(_BoundFn&& __fn)
> : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
> { }
>
> private:
> typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
> _Ptr_type _M_result;
> _BoundFn _M_fn;
>
>
> virtual void
> _M_complete_async()
> {
>
>
>
>
>
>
> _M_set_result(_S_task_setter(_M_result, _M_fn), true);
> }
>
>
>
> virtual bool _M_is_deferred_future() const { return true; }
> };
>
>
> class __future_base::_Async_state_commonV2
> : public __future_base::_State_base
> {
> protected:
> ~_Async_state_commonV2() = default;
># 1645 "/usr/include/c++/8/future" 3
> virtual void _M_complete_async() { _M_join(); }
>
> void _M_join() { std::call_once(_M_once, &thread::join, &_M_thread); }
>
> thread _M_thread;
> once_flag _M_once;
> };
>
>
>
> template<typename _BoundFn, typename _Res>
> class __future_base::_Async_state_impl final
> : public __future_base::_Async_state_commonV2
> {
> public:
> explicit
> _Async_state_impl(_BoundFn&& __fn)
> : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
> {
> _M_thread = std::thread{ [this] {
> try
> {
> _M_set_result(_S_task_setter(_M_result, _M_fn));
> }
> catch(const __cxxabiv1::__forced_unwind&)
> {
>
> if (static_cast<bool>(_M_result))
> this->_M_break_promise(std::move(_M_result));
> throw;
> }
> } };
> }
>
>
>
>
> ~_Async_state_impl() { if (_M_thread.joinable()) _M_thread.join(); }
>
> private:
> typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
> _Ptr_type _M_result;
> _BoundFn _M_fn;
> };
>
> template<typename _BoundFn>
> inline std::shared_ptr<__future_base::_State_base>
> __future_base::_S_make_deferred_state(_BoundFn&& __fn)
> {
> typedef typename remove_reference<_BoundFn>::type __fn_type;
> typedef _Deferred_state<__fn_type> __state_type;
> return std::make_shared<__state_type>(std::move(__fn));
> }
>
> template<typename _BoundFn>
> inline std::shared_ptr<__future_base::_State_base>
> __future_base::_S_make_async_state(_BoundFn&& __fn)
> {
> typedef typename remove_reference<_BoundFn>::type __fn_type;
> typedef _Async_state_impl<__fn_type> __state_type;
> return std::make_shared<__state_type>(std::move(__fn));
> }
>
>
>
> template<typename _Fn, typename... _Args>
> future<__async_result_of<_Fn, _Args...>>
> async(launch __policy, _Fn&& __fn, _Args&&... __args)
> {
> std::shared_ptr<__future_base::_State_base> __state;
> if ((__policy & launch::async) == launch::async)
> {
> try
> {
> __state = __future_base::_S_make_async_state(
> std::thread::__make_invoker(std::forward<_Fn>(__fn),
> std::forward<_Args>(__args)...)
> );
> }
>
> catch(const system_error& __e)
> {
> if (__e.code() != errc::resource_unavailable_try_again
> || (__policy & launch::deferred) != launch::deferred)
> throw;
> }
>
> }
> if (!__state)
> {
> __state = __future_base::_S_make_deferred_state(
> std::thread::__make_invoker(std::forward<_Fn>(__fn),
> std::forward<_Args>(__args)...));
> }
> return future<__async_result_of<_Fn, _Args...>>(__state);
> }
>
>
> template<typename _Fn, typename... _Args>
> inline future<__async_result_of<_Fn, _Args...>>
> async(_Fn&& __fn, _Args&&... __args)
> {
> return std::async(launch::async|launch::deferred,
> std::forward<_Fn>(__fn),
> std::forward<_Args>(__args)...);
> }
>
>
>
>
>
>
>}
># 24 "/usr/include/boost/asio/packaged_task.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/packaged_task.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>
>
>template <typename Result, typename... Args, typename Signature>
>class async_result<std::packaged_task<Result(Args...)>, Signature>
>{
>public:
>
> typedef std::packaged_task<Result(Args...)> completion_handler_type;
>
>
>
> typedef std::future<Result> return_type;
>
>
> explicit async_result(completion_handler_type& h)
> : future_(h.get_future())
> {
> }
>
>
> return_type get()
> {
> return std::move(future_);
> }
>
>private:
> return_type future_;
>};
># 120 "/usr/include/boost/asio/packaged_task.hpp" 3 4
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 124 "/usr/include/boost/asio/packaged_task.hpp" 2 3 4
># 102 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/placeholders.hpp" 1 3 4
># 21 "/usr/include/boost/asio/placeholders.hpp" 3 4
># 1 "/usr/include/boost/bind/arg.hpp" 1 3 4
># 23 "/usr/include/boost/bind/arg.hpp" 3 4
># 1 "/usr/include/boost/is_placeholder.hpp" 1 3 4
># 21 "/usr/include/boost/is_placeholder.hpp" 3 4
>namespace boost
>{
>
>template< class T > struct is_placeholder
>{
> enum _vt { value = 0 };
>};
>
>}
># 24 "/usr/include/boost/bind/arg.hpp" 2 3 4
>
>namespace boost
>{
>
>template<bool Eq> struct _arg_eq
>{
>};
>
>template<> struct _arg_eq<true>
>{
> typedef void type;
>};
>
>template< int I > struct arg
>{
> constexpr arg()
> {
> }
>
> template< class T > constexpr arg( T const & , typename _arg_eq::value >::type * = 0 )
> {
> }
>};
>
>template< int I > constexpr bool operator==( arg const &, arg const & )
>{
> return true;
>}
>
>
>
>template< int I > struct is_placeholder< arg >
>{
> enum _vt { value = I };
>};
>
>template< int I > struct is_placeholder< arg (*) () >
>{
> enum _vt { value = I };
>};
>
>
>
>}
># 22 "/usr/include/boost/asio/placeholders.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/placeholders.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace placeholders {
># 65 "/usr/include/boost/asio/placeholders.hpp" 3 4
>inline boost::arg<1> error()
>{
> return boost::arg<1>();
>}
>
>inline boost::arg<2> bytes_transferred()
>{
> return boost::arg<2>();
>}
>
>inline boost::arg<2> iterator()
>{
> return boost::arg<2>();
>}
>
>inline boost::arg<2> results()
>{
> return boost::arg<2>();
>}
>
>inline boost::arg<2> endpoint()
>{
> return boost::arg<2>();
>}
>
>inline boost::arg<2> signal_number()
>{
> return boost::arg<2>();
>}
># 147 "/usr/include/boost/asio/placeholders.hpp" 3 4
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 152 "/usr/include/boost/asio/placeholders.hpp" 2 3 4
># 103 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/posix/basic_descriptor.hpp" 1 3 4
># 104 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/posix/basic_stream_descriptor.hpp" 1 3 4
># 105 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/posix/descriptor.hpp" 1 3 4
># 28 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 1 3 4
># 29 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 30 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace descriptor_ops {
>
>
>enum
>{
>
> user_set_non_blocking = 1,
>
>
> internal_non_blocking = 2,
>
>
> non_blocking = user_set_non_blocking | internal_non_blocking,
>
>
> possible_dup = 4
>};
>
>typedef unsigned char state_type;
>
>template <typename ReturnType>
>inline ReturnType error_wrapper(ReturnType return_value,
> boost::system::error_code& ec)
>{
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
> return return_value;
>}
>
>inline int open(const char* path, int flags,
> boost::system::error_code& ec);
>
>inline int close(int d, state_type& state,
> boost::system::error_code& ec);
>
>inline bool set_user_non_blocking(int d,
> state_type& state, bool value, boost::system::error_code& ec);
>
>inline bool set_internal_non_blocking(int d,
> state_type& state, bool value, boost::system::error_code& ec);
>
>typedef iovec buf;
>
>inline std::size_t sync_read(int d, state_type state, buf* bufs,
> std::size_t count, bool all_empty, boost::system::error_code& ec);
>
>inline bool non_blocking_read(int d, buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred);
>
>inline std::size_t sync_write(int d, state_type state,
> const buf* bufs, std::size_t count, bool all_empty,
> boost::system::error_code& ec);
>
>inline bool non_blocking_write(int d,
> const buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred);
>
>inline int ioctl(int d, state_type& state, long cmd,
> ioctl_arg_type* arg, boost::system::error_code& ec);
>
>inline int fcntl(int d, int cmd, boost::system::error_code& ec);
>
>inline int fcntl(int d, int cmd,
> long arg, boost::system::error_code& ec);
>
>inline int poll_read(int d,
> state_type state, boost::system::error_code& ec);
>
>inline int poll_write(int d,
> state_type state, boost::system::error_code& ec);
>
>inline int poll_error(int d,
> state_type state, boost::system::error_code& ec);
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 114 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
># 1 "/usr/include/c++/8/cerrno" 1 3 4
># 39 "/usr/include/c++/8/cerrno" 3 4
> 
># 40 "/usr/include/c++/8/cerrno" 3
># 20 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>namespace descriptor_ops {
>
>int open(const char* path, int flags, boost::system::error_code& ec)
>{
> (*__errno_location ()) = 0;
> int result = error_wrapper(::open(path, flags), ec);
> if (result >= 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int close(int d, state_type& state, boost::system::error_code& ec)
>{
> int result = 0;
> if (d != -1)
> {
> (*__errno_location ()) = 0;
> result = error_wrapper(::close(d), ec);
>
> if (result != 0
> && (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again))
> {
># 66 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
> ioctl_arg_type arg = 0;
> ::ioctl(d, 0x5421, &arg);
>
> state &= ~non_blocking;
>
> (*__errno_location ()) = 0;
> result = error_wrapper(::close(d), ec);
> }
> }
>
> if (result == 0)
> ec = boost::system::error_code();
> return result;
>}
>
>bool set_user_non_blocking(int d, state_type& state,
> bool value, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> (*__errno_location ()) = 0;
># 100 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(d, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= user_set_non_blocking;
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> return true;
> }
>
> return false;
>}
>
>bool set_internal_non_blocking(int d, state_type& state,
> bool value, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return false;
> }
>
> if (!value && (state & user_set_non_blocking))
> {
>
>
>
> ec = boost::asio::error::invalid_argument;
> return false;
> }
>
> (*__errno_location ()) = 0;
># 150 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 3 4
> ioctl_arg_type arg = (value ? 1 : 0);
> int result = error_wrapper(::ioctl(d, 0x5421, &arg), ec);
>
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
> if (value)
> state |= internal_non_blocking;
> else
> state &= ~internal_non_blocking;
> return true;
> }
>
> return false;
>}
>
>std::size_t sync_read(int d, state_type state, buf* bufs,
> std::size_t count, bool all_empty, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::readv(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (bytes > 0)
> return bytes;
>
>
> if (bytes == 0)
> {
> ec = boost::asio::error::eof;
> return 0;
> }
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (descriptor_ops::poll_read(d, 0, ec) < 0)
> return 0;
> }
>}
>
>bool non_blocking_read(int d, buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred)
>{
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::readv(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (bytes == 0)
> {
> ec = boost::asio::error::eof;
> return true;
> }
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes > 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>std::size_t sync_write(int d, state_type state, const buf* bufs,
> std::size_t count, bool all_empty, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return 0;
> }
>
>
> if (all_empty)
> {
> ec = boost::system::error_code();
> return 0;
> }
>
>
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::writev(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (bytes > 0)
> return bytes;
>
>
> if ((state & user_set_non_blocking)
> || (ec != boost::asio::error::would_block
> && ec != boost::asio::error::try_again))
> return 0;
>
>
> if (descriptor_ops::poll_write(d, 0, ec) < 0)
> return 0;
> }
>}
>
>bool non_blocking_write(int d, const buf* bufs, std::size_t count,
> boost::system::error_code& ec, std::size_t& bytes_transferred)
>{
> for (;;)
> {
>
> (*__errno_location ()) = 0;
> signed_size_type bytes = error_wrapper(::writev(
> d, bufs, static_cast<int>(count)), ec);
>
>
> if (ec == boost::asio::error::interrupted)
> continue;
>
>
> if (ec == boost::asio::error::would_block
> || ec == boost::asio::error::try_again)
> return false;
>
>
> if (bytes >= 0)
> {
> ec = boost::system::error_code();
> bytes_transferred = bytes;
> }
> else
> bytes_transferred = 0;
>
> return true;
> }
>}
>
>int ioctl(int d, state_type& state, long cmd,
> ioctl_arg_type* arg, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> (*__errno_location ()) = 0;
> int result = error_wrapper(::ioctl(d, cmd, arg), ec);
>
> if (result >= 0)
> {
> ec = boost::system::error_code();
>
>
>
>
>
>
>
> if (cmd == static_cast<long>(0x5421))
> {
> if (*arg)
> {
> state |= user_set_non_blocking;
> }
> else
> {
>
>
>
> state &= ~(user_set_non_blocking | internal_non_blocking);
> }
> }
> }
>
> return result;
>}
>
>int fcntl(int d, int cmd, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> (*__errno_location ()) = 0;
> int result = error_wrapper(::fcntl(d, cmd), ec);
> if (result != -1)
> ec = boost::system::error_code();
> return result;
>}
>
>int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> (*__errno_location ()) = 0;
> int result = error_wrapper(::fcntl(d, cmd, arg), ec);
> if (result != -1)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_read(int d, state_type state, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> pollfd fds;
> fds.fd = d;
> fds.events = 0x001;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> (*__errno_location ()) = 0;
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_write(int d, state_type state, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> pollfd fds;
> fds.fd = d;
> fds.events = 0x004;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> (*__errno_location ()) = 0;
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>int poll_error(int d, state_type state, boost::system::error_code& ec)
>{
> if (d == -1)
> {
> ec = boost::asio::error::bad_descriptor;
> return -1;
> }
>
> pollfd fds;
> fds.fd = d;
> fds.events = 0x002 | 0x008 | 0x010;
> fds.revents = 0;
> int timeout = (state & user_set_non_blocking) ? 0 : -1;
> (*__errno_location ()) = 0;
> int result = error_wrapper(::poll(&fds, 1, timeout), ec);
> if (result == 0)
> ec = (state & user_set_non_blocking)
> ? boost::asio::error::would_block : boost::system::error_code();
> else if (result > 0)
> ec = boost::system::error_code();
> return result;
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 471 "/usr/include/boost/asio/detail/impl/descriptor_ops.ipp" 2 3 4
># 117 "/usr/include/boost/asio/detail/descriptor_ops.hpp" 2 3 4
># 29 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class descriptor_read_op_base : public reactor_op
>{
>public:
> descriptor_read_op_base(int descriptor,
> const MutableBufferSequence& buffers, func_type complete_func)
> : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
> descriptor_(descriptor),
> buffers_(buffers)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(o->buffers_);
>
> status result = descriptor_ops::non_blocking_read(o->descriptor_,
> bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
> ? done : not_done;
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> int descriptor_;
> MutableBufferSequence buffers_;
>};
>
>template <typename MutableBufferSequence, typename Handler>
>class descriptor_read_op
> : public descriptor_read_op_base<MutableBufferSequence>
>{
>public:
> struct ptr { Handler* h; descriptor_read_op* v; descriptor_read_op* p; ~ptr() { reset(); } static descriptor_read_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_read_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~descriptor_read_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_read_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<descriptor_read_op*>(v), 1); v = 0; } } };
>
> descriptor_read_op(int descriptor,
> const MutableBufferSequence& buffers, Handler& handler)
> : descriptor_read_op_base<MutableBufferSequence>(
> descriptor, buffers, &descriptor_read_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 127 "/usr/include/boost/asio/detail/descriptor_read_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
># 1 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 1 3 4
># 30 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename ConstBufferSequence>
>class descriptor_write_op_base : public reactor_op
>{
>public:
> descriptor_write_op_base(int descriptor,
> const ConstBufferSequence& buffers, func_type complete_func)
> : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
> descriptor_(descriptor),
> buffers_(buffers)
> {
> }
>
> static status do_perform(reactor_op* base)
> {
> descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
>
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(o->buffers_);
>
> status result = descriptor_ops::non_blocking_write(o->descriptor_,
> bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
> ? done : not_done;
>
> (void)0
> ;
>
> return result;
> }
>
>private:
> int descriptor_;
> ConstBufferSequence buffers_;
>};
>
>template <typename ConstBufferSequence, typename Handler>
>class descriptor_write_op
> : public descriptor_write_op_base<ConstBufferSequence>
>{
>public:
> struct ptr { Handler* h; descriptor_write_op* v; descriptor_write_op* p; ~ptr() { reset(); } static descriptor_write_op* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_write_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~descriptor_write_op(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<descriptor_write_op> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<descriptor_write_op*>(v), 1); v = 0; } } };
>
> descriptor_write_op(int descriptor,
> const ConstBufferSequence& buffers, Handler& handler)
> : descriptor_write_op_base<ConstBufferSequence>(
> descriptor, buffers, &descriptor_write_op::do_complete),
> handler_(static_cast<Handler&&>(handler))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
> ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
> handler_work<Handler> w(o->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, std::size_t>
> handler(o->handler_, o->ec_, o->bytes_transferred_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 127 "/usr/include/boost/asio/detail/descriptor_write_op.hpp" 2 3 4
># 31 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/posix/descriptor_base.hpp" 1 3 4
># 26 "/usr/include/boost/asio/posix/descriptor_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/posix/descriptor_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace posix {
>
>
>
>class descriptor_base
>{
>public:
>
>
>
>
> enum wait_type
> {
>
> wait_read,
>
>
> wait_write,
>
>
> wait_error
> };
># 73 "/usr/include/boost/asio/posix/descriptor_base.hpp" 3 4
> typedef boost::asio::detail::io_control::bytes_readable bytes_readable;
>
>
>protected:
>
> ~descriptor_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 88 "/usr/include/boost/asio/posix/descriptor_base.hpp" 2 3 4
># 38 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 40 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class reactive_descriptor_service :
> public service_base<reactive_descriptor_service>
>{
>public:
>
> typedef int native_handle_type;
>
>
> class implementation_type
> : private boost::asio::detail::noncopyable
> {
> public:
>
> implementation_type()
> : descriptor_(-1),
> state_(0)
> {
> }
>
> private:
>
> friend class reactive_descriptor_service;
>
>
> int descriptor_;
>
>
> descriptor_ops::state_type state_;
>
>
> reactor::per_descriptor_data reactor_data_;
> };
>
>
> inline reactive_descriptor_service(
> boost::asio::io_context& io_context);
>
>
> inline void shutdown();
>
>
> inline void construct(implementation_type& impl);
>
>
> inline void move_construct(implementation_type& impl,
> implementation_type& other_impl);
>
>
> inline void move_assign(implementation_type& impl,
> reactive_descriptor_service& other_service,
> implementation_type& other_impl);
>
>
> inline void destroy(implementation_type& impl);
>
>
> inline boost::system::error_code assign(implementation_type& impl,
> const native_handle_type& native_descriptor,
> boost::system::error_code& ec);
>
>
> bool is_open(const implementation_type& impl) const
> {
> return impl.descriptor_ != -1;
> }
>
>
> inline boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> native_handle_type native_handle(const implementation_type& impl) const
> {
> return impl.descriptor_;
> }
>
>
> inline native_handle_type release(implementation_type& impl);
>
>
> inline boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> template <typename IO_Control_Command>
> boost::system::error_code io_control(implementation_type& impl,
> IO_Control_Command& command, boost::system::error_code& ec)
> {
> descriptor_ops::ioctl(impl.descriptor_, impl.state_,
> command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
> return ec;
> }
>
>
> bool non_blocking(const implementation_type& impl) const
> {
> return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
> }
>
>
> boost::system::error_code non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> descriptor_ops::set_user_non_blocking(
> impl.descriptor_, impl.state_, mode, ec);
> return ec;
> }
>
>
> bool native_non_blocking(const implementation_type& impl) const
> {
> return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
> }
>
>
> boost::system::error_code native_non_blocking(implementation_type& impl,
> bool mode, boost::system::error_code& ec)
> {
> descriptor_ops::set_internal_non_blocking(
> impl.descriptor_, impl.state_, mode, ec);
> return ec;
> }
>
>
>
> boost::system::error_code wait(implementation_type& impl,
> posix::descriptor_base::wait_type w, boost::system::error_code& ec)
> {
> switch (w)
> {
> case posix::descriptor_base::wait_read:
> descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
> break;
> case posix::descriptor_base::wait_write:
> descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
> break;
> case posix::descriptor_base::wait_error:
> descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec);
> break;
> default:
> ec = boost::asio::error::invalid_argument;
> break;
> }
>
> return ec;
> }
>
>
>
> template <typename Handler>
> void async_wait(implementation_type& impl,
> posix::descriptor_base::wait_type w, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_wait_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> int op_type;
> switch (w)
> {
> case posix::descriptor_base::wait_read:
> op_type = reactor::read_op;
> break;
> case posix::descriptor_base::wait_write:
> op_type = reactor::write_op;
> break;
> case posix::descriptor_base::wait_error:
> op_type = reactor::except_op;
> break;
> default:
> p.p->ec_ = boost::asio::error::invalid_argument;
> reactor_.post_immediate_completion(p.p, is_continuation);
> p.v = p.p = 0;
> return;
> }
>
> start_op(impl, op_type, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename ConstBufferSequence>
> size_t write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence> bufs(buffers);
>
> return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
> bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
> }
>
>
> size_t write_some(implementation_type& impl,
> const null_buffers&, boost::system::error_code& ec)
> {
>
> descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef descriptor_write_op<ConstBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.descriptor_, buffers, handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, true,
> buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence>::all_empty(buffers));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_write_some(implementation_type& impl,
> const null_buffers&, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>
> template <typename MutableBufferSequence>
> size_t read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
> {
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence> bufs(buffers);
>
> return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
> bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
> }
>
>
> size_t read_some(implementation_type& impl,
> const null_buffers&, boost::system::error_code& ec)
> {
>
> descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
>
> return 0;
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef descriptor_read_op<MutableBufferSequence, Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(impl.descriptor_, buffers, handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::read_op, p.p, is_continuation, true,
> buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence>::all_empty(buffers));
> p.v = p.p = 0;
> }
>
>
> template <typename Handler>
> void async_read_some(implementation_type& impl,
> const null_buffers&, Handler& handler)
> {
> bool is_continuation =
> boost_asio_handler_cont_helpers::is_continuation(handler);
>
>
> typedef reactive_null_buffers_op<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_op(impl, reactor::read_op, p.p, is_continuation, false, false);
> p.v = p.p = 0;
> }
>
>private:
>
> inline void start_op(implementation_type& impl, int op_type,
> reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
>
>
> reactor& reactor_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 381 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>reactive_descriptor_service::reactive_descriptor_service(
> boost::asio::io_context& io_context)
> : service_base<reactive_descriptor_service>(io_context),
> reactor_(boost::asio::use_service<reactor>(io_context))
>{
> reactor_.init_task();
>}
>
>void reactive_descriptor_service::shutdown()
>{
>}
>
>void reactive_descriptor_service::construct(
> reactive_descriptor_service::implementation_type& impl)
>{
> impl.descriptor_ = -1;
> impl.state_ = 0;
>}
>
>void reactive_descriptor_service::move_construct(
> reactive_descriptor_service::implementation_type& impl,
> reactive_descriptor_service::implementation_type& other_impl)
>{
> impl.descriptor_ = other_impl.descriptor_;
> other_impl.descriptor_ = -1;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> reactor_.move_descriptor(impl.descriptor_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_descriptor_service::move_assign(
> reactive_descriptor_service::implementation_type& impl,
> reactive_descriptor_service& other_service,
> reactive_descriptor_service::implementation_type& other_impl)
>{
> destroy(impl);
>
> impl.descriptor_ = other_impl.descriptor_;
> other_impl.descriptor_ = -1;
>
> impl.state_ = other_impl.state_;
> other_impl.state_ = 0;
>
> other_service.reactor_.move_descriptor(impl.descriptor_,
> impl.reactor_data_, other_impl.reactor_data_);
>}
>
>void reactive_descriptor_service::destroy(
> reactive_descriptor_service::implementation_type& impl)
>{
> if (is_open(impl))
> {
> (void)0
> ;
>
> reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
> (impl.state_ & descriptor_ops::possible_dup) == 0);
>
> boost::system::error_code ignored_ec;
> descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
>
> reactor_.cleanup_descriptor_data(impl.reactor_data_);
> }
>}
>
>boost::system::error_code reactive_descriptor_service::assign(
> reactive_descriptor_service::implementation_type& impl,
> const native_handle_type& native_descriptor, boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> if (int err = reactor_.register_descriptor(
> native_descriptor, impl.reactor_data_))
> {
> ec = boost::system::error_code(err,
> boost::asio::error::get_system_category());
> return ec;
> }
>
> impl.descriptor_ = native_descriptor;
> impl.state_ = descriptor_ops::possible_dup;
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code reactive_descriptor_service::close(
> reactive_descriptor_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> (void)0
> ;
>
> reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
> (impl.state_ & descriptor_ops::possible_dup) == 0);
>
> descriptor_ops::close(impl.descriptor_, impl.state_, ec);
>
> reactor_.cleanup_descriptor_data(impl.reactor_data_);
> }
> else
> {
> ec = boost::system::error_code();
> }
>
>
>
>
>
>
>
> construct(impl);
>
> return ec;
>}
>
>reactive_descriptor_service::native_handle_type
>reactive_descriptor_service::release(
> reactive_descriptor_service::implementation_type& impl)
>{
> native_handle_type descriptor = impl.descriptor_;
>
> if (is_open(impl))
> {
> (void)0
> ;
>
> reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
> reactor_.cleanup_descriptor_data(impl.reactor_data_);
> construct(impl);
> }
>
> return descriptor;
>}
>
>boost::system::error_code reactive_descriptor_service::cancel(
> reactive_descriptor_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> if (!is_open(impl))
> {
> ec = boost::asio::error::bad_descriptor;
> return ec;
> }
>
> (void)0
> ;
>
> reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
> ec = boost::system::error_code();
> return ec;
>}
>
>void reactive_descriptor_service::start_op(
> reactive_descriptor_service::implementation_type& impl,
> int op_type, reactor_op* op, bool is_continuation,
> bool is_non_blocking, bool noop)
>{
> if (!noop)
> {
> if ((impl.state_ & descriptor_ops::non_blocking) ||
> descriptor_ops::set_internal_non_blocking(
> impl.descriptor_, impl.state_, true, op->ec_))
> {
> reactor_.start_op(op_type, impl.descriptor_,
> impl.reactor_data_, op, is_continuation, is_non_blocking);
> return;
> }
> }
>
> reactor_.post_immediate_completion(op, is_continuation);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 219 "/usr/include/boost/asio/detail/impl/reactive_descriptor_service.ipp" 2 3 4
># 384 "/usr/include/boost/asio/detail/reactive_descriptor_service.hpp" 2 3 4
># 29 "/usr/include/boost/asio/posix/descriptor.hpp" 2 3 4
># 40 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 41 "/usr/include/boost/asio/posix/descriptor.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace posix {
># 55 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
>class descriptor
> : protected basic_io_object<boost::asio::detail::reactive_descriptor_service>,
> public descriptor_base
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
>
>
>
> typedef boost::asio::detail::reactive_descriptor_service::native_handle_type native_handle_type;
>
>
>
> typedef descriptor lowest_layer_type;
># 81 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> explicit descriptor(boost::asio::io_context& io_context)
> : basic_io_object<boost::asio::detail::reactive_descriptor_service>(io_context)
> {
> }
># 99 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> descriptor(boost::asio::io_context& io_context,
> const native_handle_type& native_descriptor)
> : basic_io_object<boost::asio::detail::reactive_descriptor_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_descriptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 120 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> descriptor(descriptor&& other)
> : basic_io_object<boost::asio::detail::reactive_descriptor_service>(std::move(other))
> {
> }
># 135 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> descriptor& operator=(descriptor&& other)
> {
> basic_io_object<boost::asio::detail::reactive_descriptor_service>::operator=(std::move(other));
> return *this;
> }
># 152 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<boost::asio::detail::reactive_descriptor_service>::get_io_context();
> }
># 166 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<boost::asio::detail::reactive_descriptor_service>::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<boost::asio::detail::reactive_descriptor_service>::get_executor();
> }
># 187 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return *this;
> }
># 201 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return *this;
> }
># 214 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> void assign(const native_handle_type& native_descriptor)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_descriptor, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 230 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::system::error_code assign(const native_handle_type& native_descriptor,
> boost::system::error_code& ec)
> {
> this->get_service().assign(
> this->get_implementation(), native_descriptor, ec);
> return ec;
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 253 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 269 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> this->get_service().close(this->get_implementation(), ec);
> return ec;
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 296 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> native_handle_type release()
> {
> return this->get_service().release(this->get_implementation());
> }
># 309 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 324 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> this->get_service().cancel(this->get_implementation(), ec);
> return ec;
> }
># 352 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> template <typename IoControlCommand>
> void io_control(IoControlCommand& command)
> {
> boost::system::error_code ec;
> this->get_service().io_control(this->get_implementation(), command, ec);
> boost::asio::detail::throw_error(ec, "io_control");
> }
># 387 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> template <typename IoControlCommand>
> boost::system::error_code io_control(IoControlCommand& command,
> boost::system::error_code& ec)
> {
> this->get_service().io_control(this->get_implementation(), command, ec);
> return ec;
> }
># 406 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> bool non_blocking() const
> {
> return this->get_service().non_blocking(this->get_implementation());
> }
># 424 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> void non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "non_blocking");
> }
># 444 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::system::error_code non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> this->get_service().non_blocking(this->get_implementation(), mode, ec);
> return ec;
> }
># 465 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> bool native_non_blocking() const
> {
> return this->get_service().native_non_blocking(
> this->get_implementation());
> }
># 486 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> void native_non_blocking(bool mode)
> {
> boost::system::error_code ec;
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> boost::asio::detail::throw_error(ec, "native_non_blocking");
> }
># 509 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::system::error_code native_non_blocking(
> bool mode, boost::system::error_code& ec)
> {
> this->get_service().native_non_blocking(
> this->get_implementation(), mode, ec);
> return ec;
> }
># 533 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> void wait(wait_type w)
> {
> boost::system::error_code ec;
> this->get_service().wait(this->get_implementation(), w, ec);
> boost::asio::detail::throw_error(ec, "wait");
> }
># 559 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> boost::system::error_code wait(wait_type w, boost::system::error_code& ec)
> {
> this->get_service().wait(this->get_implementation(), w, ec);
> return ec;
> }
># 603 "/usr/include/boost/asio/posix/descriptor.hpp" 3 4
> template <typename WaitHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void (boost::system::error_code)>::return_type
>
> async_wait(wait_type w, WaitHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WaitHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "WaitHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WaitHandler,
> void (boost::system::error_code)> init(handler);
>
> this->get_service().async_wait(
> this->get_implementation(), w, init.completion_handler);
>
> return init.result.get();
> }
>
>protected:
>
>
>
>
>
>
> ~descriptor()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 638 "/usr/include/boost/asio/posix/descriptor.hpp" 2 3 4
># 106 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 1 3 4
># 28 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
>namespace boost {
>namespace asio {
>namespace posix {
># 48 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
>class stream_descriptor
> : public descriptor
>{
>public:
># 62 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> explicit stream_descriptor(boost::asio::io_context& io_context)
> : descriptor(io_context)
> {
> }
># 80 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> stream_descriptor(boost::asio::io_context& io_context,
> const native_handle_type& native_descriptor)
> : descriptor(io_context, native_descriptor)
> {
> }
># 97 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> stream_descriptor(stream_descriptor&& other)
> : descriptor(std::move(other))
> {
> }
># 113 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> stream_descriptor& operator=(stream_descriptor&& other)
> {
> descriptor::operator=(std::move(other));
> return *this;
> }
># 147 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return s;
> }
># 173 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> }
># 216 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> boost::asio::async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_write_some(
> this->get_implementation(), buffers, init.completion_handler);
>
> return init.result.get();
> }
># 263 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return s;
> }
># 290 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> }
># 334 "/usr/include/boost/asio/posix/stream_descriptor.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> boost::asio::async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_read_some(
> this->get_implementation(), buffers, init.completion_handler);
>
> return init.result.get();
> }
>};
>
>
>}
>}
>}
># 108 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/posix/stream_descriptor_service.hpp" 1 3 4
># 109 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/raw_socket_service.hpp" 1 3 4
># 111 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/read.hpp" 1 3 4
># 28 "/usr/include/boost/asio/read.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/read.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 77 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type* = 0);
># 119 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type* = 0);
># 172 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type* = 0);
># 219 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type* = 0);
># 254 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 287 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 331 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 377 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 415 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
># 444 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 483 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition);
># 524 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 601 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> ReadHandler&& handler,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type* = 0);
># 674 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type* = 0);
># 735 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> ReadHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 804 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type* = 0);
># 867 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
> ReadHandler&& handler);
># 929 "/usr/include/boost/asio/read.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
>
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 946 "/usr/include/boost/asio/read.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/read.hpp" 1 3 4
># 35 "/usr/include/boost/asio/impl/read.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 36 "/usr/include/boost/asio/impl/read.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> template <typename SyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition>
> std::size_t read_buffer_sequence(SyncReadStream& s,
> const MutableBufferSequence& buffers, const MutableBufferIterator&,
> CompletionCondition completion_condition, boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<mutable_buffer,
> MutableBufferSequence, MutableBufferIterator> tmp(buffers);
> while (!tmp.empty())
> {
> if (std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, tmp.total_consumed())))
> tmp.consume(s.read_some(tmp.prepare(max_size), ec));
> else
> break;
> }
> return tmp.total_consumed();;
> }
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type*)
>{
> return detail::read_buffer_sequence(s, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence>
>inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence>
>inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type*)
>{
> return read(s, buffers, transfer_all(), ec);
>}
>
>template <typename SyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition>
>inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename DynamicBuffer,
> typename CompletionCondition>
>std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> typename decay<DynamicBuffer>::type b(
> static_cast<DynamicBuffer&&>(buffers));
>
> ec = boost::system::error_code();
> std::size_t total_transferred = 0;
> std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> std::size_t bytes_available = std::min<std::size_t>(
> std::max<std::size_t>(512, b.capacity() - b.size()),
> std::min<std::size_t>(max_size, b.max_size() - b.size()));
> while (bytes_available > 0)
> {
> std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
> b.commit(bytes_transferred);
> total_transferred += bytes_transferred;
> max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> bytes_available = std::min<std::size_t>(
> std::max<std::size_t>(512, b.capacity() - b.size()),
> std::min<std::size_t>(max_size, b.max_size() - b.size()));
> }
> return total_transferred;
>}
>
>template <typename SyncReadStream, typename DynamicBuffer>
>inline std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s,
> static_cast<DynamicBuffer&&>(buffers), transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename DynamicBuffer>
>inline std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::system::error_code& ec,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> return read(s, static_cast<DynamicBuffer&&>(buffers),
> transfer_all(), ec);
>}
>
>template <typename SyncReadStream, typename DynamicBuffer,
> typename CompletionCondition>
>inline std::size_t read(SyncReadStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read(s,
> static_cast<DynamicBuffer&&>(buffers),
> completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read");
> return bytes_transferred;
>}
>
>
>
>
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> return read(s, basic_streambuf_ref<Allocator>(b), completion_condition, ec);
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b)
>{
> return read(s, basic_streambuf_ref<Allocator>(b));
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return read(s, basic_streambuf_ref<Allocator>(b), ec);
>}
>
>template <typename SyncReadStream, typename Allocator,
> typename CompletionCondition>
>inline std::size_t read(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> return read(s, basic_streambuf_ref<Allocator>(b), completion_condition);
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler>
> class read_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(buffers),
> start_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_op(const read_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> read_op(read_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> do
> {
> stream_.async_read_some(buffers_.prepare(max_size),
> static_cast<read_op&&>(*this));
> return; default:
> buffers_.consume(bytes_transferred);
> if ((!ec && bytes_transferred == 0) || buffers_.empty())
> break;
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> } while (max_size > 0);
>
> handler_(ec, buffers_.total_consumed());
> }
> }
>
>
> AsyncReadStream& stream_;
> boost::asio::detail::consuming_buffers<mutable_buffer,
> MutableBufferSequence, MutableBufferIterator> buffers_;
> int start_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_op<AsyncReadStream, MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler>
> inline void start_read_buffer_sequence_op(AsyncReadStream& stream,
> const MutableBufferSequence& buffers, const MutableBufferIterator&,
> CompletionCondition completion_condition, ReadHandler& handler)
> {
> detail::read_op<AsyncReadStream, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>(
> stream, buffers, completion_condition, handler)(
> boost::system::error_code(), 0, 1);
> }
>}
>
>
>
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_op<AsyncReadStream, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_op<AsyncReadStream, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition,
> typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_op<AsyncReadStream, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_op<AsyncReadStream, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_read_buffer_sequence_op(s, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition,
> init.completion_handler);
>
> return init.result.get();
>}
>
>template <typename AsyncReadStream, typename MutableBufferSequence,
> typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
> ReadHandler&& handler,
> typename enable_if<
> is_mutable_buffer_sequence<MutableBufferSequence>::value
> >::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_read_buffer_sequence_op(s, buffers,
> boost::asio::buffer_sequence_begin(buffers), transfer_all(),
> init.completion_handler);
>
> return init.result.get();
>}
>
>namespace detail
>{
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler>
> class read_dynbuf_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> template <typename BufferSequence>
> read_dynbuf_op(AsyncReadStream& stream,
> BufferSequence&& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> stream_(stream),
> buffers_(static_cast<BufferSequence&&>(buffers)),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_dynbuf_op(const read_dynbuf_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(other.buffers_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_dynbuf_op(read_dynbuf_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> stream_(other.stream_),
> buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size, bytes_available;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = std::min<std::size_t>(
> std::max<std::size_t>(512,
> buffers_.capacity() - buffers_.size()),
> std::min<std::size_t>(max_size,
> buffers_.max_size() - buffers_.size()));
> for (;;)
> {
> stream_.async_read_some(buffers_.prepare(bytes_available),
> static_cast<read_dynbuf_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> buffers_.commit(bytes_transferred);
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = std::min<std::size_t>(
> std::max<std::size_t>(512,
> buffers_.capacity() - buffers_.size()),
> std::min<std::size_t>(max_size,
> buffers_.max_size() - buffers_.size()));
> if ((!ec && bytes_transferred == 0) || bytes_available == 0)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncReadStream& stream_;
> DynamicBuffer buffers_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_dynbuf_op<AsyncReadStream, DynamicBuffer,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_dynbuf_op<AsyncReadStream, DynamicBuffer,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_dynbuf_op<AsyncReadStream, DynamicBuffer,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_dynbuf_op<AsyncReadStream, DynamicBuffer,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename CompletionCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_dynbuf_op<AsyncReadStream, DynamicBuffer,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_dynbuf_op<AsyncReadStream,
> DynamicBuffer, CompletionCondition, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_dynbuf_op<AsyncReadStream,
> DynamicBuffer, CompletionCondition, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_dynbuf_op<AsyncReadStream,
> DynamicBuffer, CompletionCondition, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_dynbuf_op<AsyncReadStream,
> DynamicBuffer, CompletionCondition, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> ReadHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
> return async_read(s,
> static_cast<DynamicBuffer&&>(buffers),
> transfer_all(), static_cast<ReadHandler&&>(handler));
>}
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler,
> typename enable_if<
> is_dynamic_buffer<DynamicBuffer>::value
> >::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_dynbuf_op<AsyncReadStream,
> typename decay<DynamicBuffer>::type,
> CompletionCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> s, static_cast<DynamicBuffer&&>(buffers),
> completion_condition, init.completion_handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
> ReadHandler&& handler)
>{
> return async_read(s, basic_streambuf_ref<Allocator>(b),
> static_cast<ReadHandler&&>(handler));
>}
>
>template <typename AsyncReadStream, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
> return async_read(s, basic_streambuf_ref<Allocator>(b),
> completion_condition, static_cast<ReadHandler&&>(handler));
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 716 "/usr/include/boost/asio/impl/read.hpp" 2 3 4
># 948 "/usr/include/boost/asio/read.hpp" 2 3 4
># 112 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/read_at.hpp" 1 3 4
># 28 "/usr/include/boost/asio/read_at.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/read_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 81 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers);
># 126 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> boost::system::error_code& ec);
># 181 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition);
># 230 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 267 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b);
># 299 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 341 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition);
># 385 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 462 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
> const MutableBufferSequence& buffers,
> ReadHandler&& handler);
># 535 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
># 592 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, ReadHandler&& handler);
># 652 "/usr/include/boost/asio/read_at.hpp" 3 4
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler);
>
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 670 "/usr/include/boost/asio/read_at.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/read_at.hpp" 1 3 4
># 35 "/usr/include/boost/asio/impl/read_at.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 36 "/usr/include/boost/asio/impl/read_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename MutableBufferIterator, typename CompletionCondition>
> std::size_t read_at_buffer_sequence(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> const MutableBufferIterator&, CompletionCondition completion_condition,
> boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<mutable_buffer,
> MutableBufferSequence, MutableBufferIterator> tmp(buffers);
> while (!tmp.empty())
> {
> if (std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, tmp.total_consumed())))
> {
> tmp.consume(d.read_some_at(offset + tmp.total_consumed(),
> tmp.prepare(max_size), ec));
> }
> else
> break;
> }
> return tmp.total_consumed();;
> }
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> return detail::read_at_buffer_sequence(d, offset, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
>{
> return read_at(d, offset, buffers, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>
>
>
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> ec = boost::system::error_code();
> std::size_t total_transferred = 0;
> std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> std::size_t bytes_available = read_size_helper(b, max_size);
> while (bytes_available > 0)
> {
> std::size_t bytes_transferred = d.read_some_at(
> offset + total_transferred, b.prepare(bytes_available), ec);
> b.commit(bytes_transferred);
> total_transferred += bytes_transferred;
> max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, total_transferred));
> bytes_available = read_size_helper(b, max_size);
> }
> return total_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, b, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessReadDevice, typename Allocator>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return read_at(d, offset, b, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition>
>inline std::size_t read_at(SyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_at(
> d, offset, b, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "read_at");
> return bytes_transferred;
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> class read_at_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_op(const read_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> read_at_op(read_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> do
> {
> device_.async_read_some_at(
> offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
> static_cast<read_at_op&&>(*this));
> return; default:
> buffers_.consume(bytes_transferred);
> if ((!ec && bytes_transferred == 0) || buffers_.empty())
> break;
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> } while (max_size > 0);
>
> handler_(ec, buffers_.total_consumed());
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> boost::asio::detail::consuming_buffers<mutable_buffer,
> MutableBufferSequence, MutableBufferIterator> buffers_;
> int start_;
> ReadHandler handler_;
> };
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler>
> inline void start_read_at_buffer_sequence_op(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> const MutableBufferIterator&, CompletionCondition completion_condition,
> ReadHandler& handler)
> {
> detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>(
> d, offset, buffers, completion_condition, handler)(
> boost::system::error_code(), 0, 1);
> }
>}
>
>
>
>template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_at_op<AsyncRandomAccessReadDevice,
> MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncRandomAccessReadDevice,
> typename MutableBufferSequence, typename MutableBufferIterator,
> typename CompletionCondition, typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
> MutableBufferIterator, CompletionCondition, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_at_op<AsyncRandomAccessReadDevice,
> MutableBufferSequence, MutableBufferIterator,
> CompletionCondition, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_read_at_buffer_sequence_op(d, offset, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition,
> init.completion_handler);
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
> typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, const MutableBufferSequence& buffers,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_read_at_buffer_sequence_op(d, offset, buffers,
> boost::asio::buffer_sequence_begin(buffers), transfer_all(),
> init.completion_handler);
>
> return init.result.get();
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> class read_at_streambuf_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> read_at_streambuf_op(AsyncRandomAccessReadDevice& device,
> uint64_t offset, basic_streambuf<Allocator>& streambuf,
> CompletionCondition completion_condition, ReadHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> streambuf_(streambuf),
> start_(0),
> total_transferred_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_at_streambuf_op(const read_at_streambuf_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> streambuf_(other.streambuf_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(other.handler_)
> {
> }
>
> read_at_streambuf_op(read_at_streambuf_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> streambuf_(other.streambuf_),
> start_(other.start_),
> total_transferred_(other.total_transferred_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size, bytes_available;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = read_size_helper(streambuf_, max_size);
> for (;;)
> {
> device_.async_read_some_at(offset_ + total_transferred_,
> streambuf_.prepare(bytes_available),
> static_cast<read_at_streambuf_op&&>(*this));
> return; default:
> total_transferred_ += bytes_transferred;
> streambuf_.commit(bytes_transferred);
> max_size = this->check_for_completion(ec, total_transferred_);
> bytes_available = read_size_helper(streambuf_, max_size);
> if ((!ec && bytes_transferred == 0) || bytes_available == 0)
> break;
> }
>
> handler_(ec, static_cast<const std::size_t&>(total_transferred_));
> }
> }
>
>
> AsyncRandomAccessReadDevice& device_;
> uint64_t offset_;
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> int start_;
> std::size_t total_transferred_;
> ReadHandler handler_;
> };
>
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename Allocator, typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessReadDevice,
> typename Allocator, typename CompletionCondition, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler, typename Allocator1>
>struct associated_allocator<
> detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
> Allocator, CompletionCondition, ReadHandler>,
> Allocator1>
>{
> typedef typename associated_allocator<ReadHandler, Allocator1>::type type;
>
> static type get(
> const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
> Allocator, CompletionCondition, ReadHandler>& h,
> const Allocator1& a = Allocator1()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator1>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncRandomAccessReadDevice, typename Executor,
> typename CompletionCondition, typename ReadHandler, typename Executor1>
>struct associated_executor<
> detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
> Executor, CompletionCondition, ReadHandler>,
> Executor1>
>{
> typedef typename associated_executor<ReadHandler, Executor1>::type type;
>
> static type get(
> const detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
> Executor, CompletionCondition, ReadHandler>& h,
> const Executor1& ex = Executor1()) noexcept
> {
> return associated_executor<ReadHandler, Executor1>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename CompletionCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> CompletionCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> d, offset, b, completion_condition, init.completion_handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessReadDevice, typename Allocator,
> typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_at(AsyncRandomAccessReadDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
> detail::transfer_all_t, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> d, offset, b, transfer_all(), init.completion_handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 641 "/usr/include/boost/asio/impl/read_at.hpp" 2 3 4
># 672 "/usr/include/boost/asio/read_at.hpp" 2 3 4
># 113 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/read_until.hpp" 1 3 4
># 22 "/usr/include/boost/asio/read_until.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/regex_fwd.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/regex_fwd.hpp" 3 4
># 1 "/usr/include/boost/regex_fwd.hpp" 1 3 4
># 24 "/usr/include/boost/regex_fwd.hpp" 3 4
># 1 "/usr/include/boost/regex/config.hpp" 1 3 4
># 42 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/regex/user.hpp" 1 3 4
># 43 "/usr/include/boost/regex/config.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/predef.h" 1 3 4
># 46 "/usr/include/boost/regex/config.hpp" 2 3 4
># 136 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/regex/config/cwchar.hpp" 1 3 4
># 22 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
># 1 "/usr/include/c++/8/cwchar" 1 3 4
># 39 "/usr/include/c++/8/cwchar" 3 4
> 
># 40 "/usr/include/c++/8/cwchar" 3
># 23 "/usr/include/boost/regex/config/cwchar.hpp" 2 3 4
># 1 "/usr/include/c++/8/cwctype" 1 3 4
># 39 "/usr/include/c++/8/cwctype" 3 4
> 
># 40 "/usr/include/c++/8/cwctype" 3
># 24 "/usr/include/boost/regex/config/cwchar.hpp" 2 3 4
># 49 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
>namespace std{
>
>
>extern "C"{
># 201 "/usr/include/boost/regex/config/cwchar.hpp" 3 4
>}
>
>
>}
># 137 "/usr/include/boost/regex/config.hpp" 2 3 4
># 249 "/usr/include/boost/regex/config.hpp" 3 4
># 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
># 250 "/usr/include/boost/regex/config.hpp" 2 3 4
># 432 "/usr/include/boost/regex/config.hpp" 3 4
>namespace boost{ namespace re_detail_106600{
>
> void* get_mem_block();
> void put_mem_block(void*);
>
>}}
># 25 "/usr/include/boost/regex_fwd.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/regex/v4/regex_fwd.hpp" 1 3 4
># 37 "/usr/include/boost/regex/v4/regex_fwd.hpp" 3 4
>namespace boost{
>
>template <class charT>
>class cpp_regex_traits;
>template <class charT>
>struct c_regex_traits;
>template <class charT>
>class w32_regex_traits;
>
>
>
>
>
>template <class charT, class implementationT = cpp_regex_traits<charT> >
>struct regex_traits;
>
>
>
>
>
>template <class charT, class traits = regex_traits<charT> >
>class basic_regex;
>
>typedef basic_regex<char, regex_traits<char> > regex;
>
>typedef basic_regex<wchar_t, regex_traits<wchar_t> > wregex;
>
>
>}
># 28 "/usr/include/boost/regex_fwd.hpp" 2 3 4
># 21 "/usr/include/boost/asio/detail/regex_fwd.hpp" 2 3 4
># 1 "/usr/include/boost/regex/v4/match_flags.hpp" 1 3 4
># 23 "/usr/include/boost/regex/v4/match_flags.hpp" 3 4
># 1 "/usr/include/boost/cstdint.hpp" 1 3 4
># 24 "/usr/include/boost/regex/v4/match_flags.hpp" 2 3 4
>
>
>
>
>namespace boost{
> namespace regex_constants{
>
>
>typedef enum _match_flags
>{
> match_default = 0,
> match_not_bol = 1,
> match_not_eol = match_not_bol << 1,
> match_not_bob = match_not_eol << 1,
> match_not_eob = match_not_bob << 1,
> match_not_bow = match_not_eob << 1,
> match_not_eow = match_not_bow << 1,
> match_not_dot_newline = match_not_eow << 1,
> match_not_dot_null = match_not_dot_newline << 1,
> match_prev_avail = match_not_dot_null << 1,
> match_init = match_prev_avail << 1,
> match_any = match_init << 1,
> match_not_null = match_any << 1,
> match_continuous = match_not_null << 1,
>
> match_partial = match_continuous << 1,
>
> match_stop = match_partial << 1,
> match_not_initial_null = match_stop,
> match_all = match_stop << 1,
> match_perl = match_all << 1,
> match_posix = match_perl << 1,
> match_nosubs = match_posix << 1,
> match_extra = match_nosubs << 1,
> match_single_line = match_extra << 1,
> match_unused1 = match_single_line << 1,
> match_unused2 = match_unused1 << 1,
> match_unused3 = match_unused2 << 1,
> match_max = match_unused3,
>
> format_perl = 0,
> format_default = 0,
> format_sed = match_max << 1,
> format_all = format_sed << 1,
> format_no_copy = format_all << 1,
> format_first_only = format_no_copy << 1,
> format_is_if = format_first_only << 1,
> format_literal = format_is_if << 1,
>
> match_not_any = match_not_bol | match_not_eol | match_not_bob
> | match_not_eob | match_not_bow | match_not_eow | match_not_dot_newline
> | match_not_dot_null | match_prev_avail | match_init | match_not_null
> | match_continuous | match_partial | match_stop | match_not_initial_null
> | match_stop | match_all | match_perl | match_posix | match_nosubs
> | match_extra | match_single_line | match_unused1 | match_unused2
> | match_unused3 | match_max | format_perl | format_default | format_sed
> | format_all | format_no_copy | format_first_only | format_is_if
> | format_literal
>
>
>} match_flags;
>
>
>
>
>typedef match_flags match_flag_type;
>
>
>
>inline match_flags operator&(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }
>inline match_flags operator|(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }
>inline match_flags operator^(match_flags m1, match_flags m2)
>{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }
>inline match_flags operator~(match_flags m1)
>{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }
>inline match_flags& operator&=(match_flags& m1, match_flags m2)
>{ m1 = m1&m2; return m1; }
>inline match_flags& operator|=(match_flags& m1, match_flags m2)
>{ m1 = m1|m2; return m1; }
>inline match_flags& operator^=(match_flags& m1, match_flags m2)
>{ m1 = m1^m2; return m1; }
>
>
>
>
>}
>
>
>
>using regex_constants::match_flag_type;
>using regex_constants::match_default;
>using regex_constants::match_not_bol;
>using regex_constants::match_not_eol;
>using regex_constants::match_not_bob;
>using regex_constants::match_not_eob;
>using regex_constants::match_not_bow;
>using regex_constants::match_not_eow;
>using regex_constants::match_not_dot_newline;
>using regex_constants::match_not_dot_null;
>using regex_constants::match_prev_avail;
>
>using regex_constants::match_any;
>using regex_constants::match_not_null;
>using regex_constants::match_continuous;
>using regex_constants::match_partial;
>
>using regex_constants::match_all;
>using regex_constants::match_perl;
>using regex_constants::match_posix;
>using regex_constants::match_nosubs;
>using regex_constants::match_extra;
>using regex_constants::match_single_line;
>
>using regex_constants::format_all;
>using regex_constants::format_sed;
>using regex_constants::format_perl;
>using regex_constants::format_default;
>using regex_constants::format_no_copy;
>using regex_constants::format_first_only;
>
>
>}
># 22 "/usr/include/boost/asio/detail/regex_fwd.hpp" 2 3 4
>
>namespace boost {
>
>template <class BidiIterator>
>struct sub_match;
>
>template <class BidiIterator, class Allocator>
>class match_results;
>
>}
># 23 "/usr/include/boost/asio/read_until.hpp" 2 3 4
># 31 "/usr/include/boost/asio/read_until.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/read_until.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> char (&has_result_type_helper(...))[2];
>
> template <typename T>
> char has_result_type_helper(T*, typename T::result_type* = 0);
>
> template <typename T>
> struct has_result_type
> {
> enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
> };
>}
>
>
>
>template <typename T>
>struct is_match_condition
>{
>
>
>
>
> enum
> {
> value = boost::asio::is_function<
> typename boost::asio::remove_pointer<T>::type>::value
> || detail::has_result_type<T>::value
> };
>
>};
># 130 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers, char delim);
># 168 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> char delim, boost::system::error_code& ec);
># 224 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::asio::string_view delim);
># 263 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::asio::string_view delim,
> boost::system::error_code& ec);
># 327 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> const boost::regex& expr);
># 368 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> const boost::regex& expr, boost::system::error_code& ec);
># 478 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream,
> typename DynamicBuffer, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> MatchCondition match_condition,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 538 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream,
> typename DynamicBuffer, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> MatchCondition match_condition, boost::system::error_code& ec,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 595 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim);
># 629 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim,
> boost::system::error_code& ec);
># 682 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::asio::string_view delim);
># 717 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::asio::string_view delim, boost::system::error_code& ec);
># 775 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr);
># 812 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> boost::system::error_code& ec);
># 920 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 976 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, boost::system::error_code& ec,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 1077 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> char delim, ReadHandler&& handler);
># 1167 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::asio::string_view delim,
> ReadHandler&& handler);
># 1265 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> const boost::regex& expr,
> ReadHandler&& handler);
># 1405 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> MatchCondition match_condition, ReadHandler&& handler,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
># 1494 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> char delim, ReadHandler&& handler);
># 1579 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::asio::string_view delim,
> ReadHandler&& handler);
># 1672 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> ReadHandler&& handler);
># 1805 "/usr/include/boost/asio/read_until.hpp" 3 4
>template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, ReadHandler&& handler,
> typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
>
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1823 "/usr/include/boost/asio/read_until.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/read_until.hpp" 1 3 4
># 34 "/usr/include/boost/asio/impl/read_until.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 35 "/usr/include/boost/asio/impl/read_until.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>template <typename SyncReadStream, typename DynamicBuffer>
>inline std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers, char delim)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s,
> static_cast<DynamicBuffer&&>(buffers), delim, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> char delim, boost::system::error_code& ec)
>{
> typename decay<DynamicBuffer>::type b(
> static_cast<DynamicBuffer&&>(buffers));
>
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename DynamicBuffer::const_buffers_type buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = b.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(data_buffers);
>
>
> iterator iter = std::find(start_pos, end, delim);
> if (iter != end)
> {
>
> ec = boost::system::error_code();
> return iter - begin + 1;
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512, b.capacity() - b.size()),
> std::min<std::size_t>(65536, b.max_size() - b.size()));
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>template <typename SyncReadStream, typename DynamicBuffer>
>inline std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::asio::string_view delim)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s,
> static_cast<DynamicBuffer&&>(buffers), delim, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>namespace detail
>{
>
>
>
>
>
>
> template <typename Iterator1, typename Iterator2>
> std::pair<Iterator1, bool> partial_search(
> Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
> {
> for (Iterator1 iter1 = first1; iter1 != last1; ++iter1)
> {
> Iterator1 test_iter1 = iter1;
> Iterator2 test_iter2 = first2;
> for (;; ++test_iter1, ++test_iter2)
> {
> if (test_iter2 == last2)
> return std::make_pair(iter1, true);
> if (test_iter1 == last1)
> {
> if (test_iter2 != first2)
> return std::make_pair(iter1, false);
> else
> break;
> }
> if (*test_iter1 != *test_iter2)
> break;
> }
> }
> return std::make_pair(last1, false);
> }
>}
>
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::asio::string_view delim, boost::system::error_code& ec)
>{
> typename decay<DynamicBuffer>::type b(
> static_cast<DynamicBuffer&&>(buffers));
>
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename DynamicBuffer::const_buffers_type buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = b.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(data_buffers);
>
>
> std::pair<iterator, bool> result = detail::partial_search(
> start_pos, end, delim.begin(), delim.end());
> if (result.first != end)
> {
> if (result.second)
> {
>
> ec = boost::system::error_code();
> return result.first - begin + delim.length();
> }
> else
> {
>
> search_position = result.first - begin;
> }
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512, b.capacity() - b.size()),
> std::min<std::size_t>(65536, b.max_size() - b.size()));
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>
>
>
>template <typename SyncReadStream, typename DynamicBuffer>
>inline std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> const boost::regex& expr)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s,
> static_cast<DynamicBuffer&&>(buffers), expr, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream, typename DynamicBuffer>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> const boost::regex& expr, boost::system::error_code& ec)
>{
> typename decay<DynamicBuffer>::type b(
> static_cast<DynamicBuffer&&>(buffers));
>
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename DynamicBuffer::const_buffers_type buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = b.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(data_buffers);
>
>
> boost::match_results<iterator,
> typename std::vector<boost::sub_match<iterator> >::allocator_type>
> match_results;
> if (regex_search(start_pos, end, match_results, expr,
> boost::match_default | boost::match_partial))
> {
> if (match_results[0].matched)
> {
>
> ec = boost::system::error_code();
> return match_results[0].second - begin;
> }
> else
> {
>
> search_position = match_results[0].first - begin;
> }
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = read_size_helper(b, 65536);
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>
>
>template <typename SyncReadStream,
> typename DynamicBuffer, typename MatchCondition>
>inline std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> MatchCondition match_condition,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = read_until(s,
> static_cast<DynamicBuffer&&>(buffers),
> match_condition, ec);
> boost::asio::detail::throw_error(ec, "read_until");
> return bytes_transferred;
>}
>
>template <typename SyncReadStream,
> typename DynamicBuffer, typename MatchCondition>
>std::size_t read_until(SyncReadStream& s,
> DynamicBuffer&& buffers,
> MatchCondition match_condition, boost::system::error_code& ec,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> typename decay<DynamicBuffer>::type b(
> static_cast<DynamicBuffer&&>(buffers));
>
> std::size_t search_position = 0;
> for (;;)
> {
>
> typedef typename DynamicBuffer::const_buffers_type buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = b.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position;
> iterator end = iterator::end(data_buffers);
>
>
> std::pair<iterator, bool> result = match_condition(start_pos, end);
> if (result.second)
> {
>
> ec = boost::system::error_code();
> return result.first - begin;
> }
> else if (result.first != end)
> {
>
> search_position = result.first - begin;
> }
> else
> {
>
> search_position = end - begin;
> }
>
>
> if (b.size() == b.max_size())
> {
> ec = error::not_found;
> return 0;
> }
>
>
> std::size_t bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512, b.capacity() - b.size()),
> std::min<std::size_t>(65536, b.max_size() - b.size()));
> b.commit(s.read_some(b.prepare(bytes_to_read), ec));
> if (ec)
> return 0;
> }
>}
>
>
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, char delim,
> boost::system::error_code& ec)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::asio::string_view delim)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), delim);
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::asio::string_view delim, boost::system::error_code& ec)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), delim, ec);
>}
>
>
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), expr);
>}
>
>template <typename SyncReadStream, typename Allocator>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> boost::system::error_code& ec)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), expr, ec);
>}
>
>
>
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, MatchCondition match_condition,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition);
>}
>
>template <typename SyncReadStream, typename Allocator, typename MatchCondition>
>inline std::size_t read_until(SyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, boost::system::error_code& ec,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> return read_until(s, basic_streambuf_ref<Allocator>(b), match_condition, ec);
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> class read_until_delim_op
> {
> public:
> template <typename BufferSequence>
> read_until_delim_op(AsyncReadStream& stream,
> BufferSequence&& buffers,
> char delim, ReadHandler& handler)
> : stream_(stream),
> buffers_(static_cast<BufferSequence&&>(buffers)),
> delim_(delim),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_delim_op(const read_until_delim_op& other)
> : stream_(other.stream_),
> buffers_(other.buffers_),
> delim_(other.delim_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_delim_op(read_until_delim_op&& other)
> : stream_(other.stream_),
> buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
> delim_(other.delim_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename DynamicBuffer::const_buffers_type
> buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = buffers_.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(data_buffers);
>
>
> iterator iter = std::find(start_pos, end, delim_);
> if (iter != end)
> {
>
> search_position_ = iter - begin + 1;
> bytes_to_read = 0;
> }
>
>
> else if (buffers_.size() == buffers_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
>
> search_position_ = end - begin;
> bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512,
> buffers_.capacity() - buffers_.size()),
> std::min<std::size_t>(65536,
> buffers_.max_size() - buffers_.size()));
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(buffers_.prepare(bytes_to_read),
> static_cast<read_until_delim_op&&>(*this));
> return; default:
> buffers_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> DynamicBuffer buffers_;
> char delim_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_until_delim_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> char delim, ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_until_delim_op<AsyncReadStream,
> typename decay<DynamicBuffer>::type,
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> s, static_cast<DynamicBuffer&&>(buffers),
> delim, init.completion_handler)(boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>namespace detail
>{
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> class read_until_delim_string_op
> {
> public:
> template <typename BufferSequence>
> read_until_delim_string_op(AsyncReadStream& stream,
> BufferSequence&& buffers,
> const std::string& delim, ReadHandler& handler)
> : stream_(stream),
> buffers_(static_cast<BufferSequence&&>(buffers)),
> delim_(delim),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_delim_string_op(const read_until_delim_string_op& other)
> : stream_(other.stream_),
> buffers_(other.buffers_),
> delim_(other.delim_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_delim_string_op(read_until_delim_string_op&& other)
> : stream_(other.stream_),
> buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
> delim_(static_cast<std::string&&>(other.delim_)),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename DynamicBuffer::const_buffers_type
> buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = buffers_.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(data_buffers);
>
>
> std::pair<iterator, bool> result = detail::partial_search(
> start_pos, end, delim_.begin(), delim_.end());
> if (result.first != end && result.second)
> {
>
> search_position_ = result.first - begin + delim_.length();
> bytes_to_read = 0;
> }
>
>
> else if (buffers_.size() == buffers_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
> if (result.first != end)
> {
>
>
> search_position_ = result.first - begin;
> }
> else
> {
>
> search_position_ = end - begin;
> }
>
> bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512,
> buffers_.capacity() - buffers_.size()),
> std::min<std::size_t>(65536,
> buffers_.max_size() - buffers_.size()));
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(buffers_.prepare(bytes_to_read),
> static_cast<read_until_delim_string_op&&>(*this));
> return; default:
> buffers_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> DynamicBuffer buffers_;
> std::string delim_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_until_delim_string_op<AsyncReadStream,
> DynamicBuffer, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> boost::asio::string_view delim,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_until_delim_string_op<AsyncReadStream,
> typename decay<DynamicBuffer>::type,
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> s, static_cast<DynamicBuffer&&>(buffers),
> static_cast<std::string>(delim),
> init.completion_handler)(boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename RegEx, typename ReadHandler>
> class read_until_expr_op
> {
> public:
> template <typename BufferSequence>
> read_until_expr_op(AsyncReadStream& stream,
> BufferSequence&& buffers,
> const boost::regex& expr, ReadHandler& handler)
> : stream_(stream),
> buffers_(static_cast<BufferSequence&&>(buffers)),
> expr_(expr),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_expr_op(const read_until_expr_op& other)
> : stream_(other.stream_),
> buffers_(other.buffers_),
> expr_(other.expr_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_expr_op(read_until_expr_op&& other)
> : stream_(other.stream_),
> buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
> expr_(other.expr_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename DynamicBuffer::const_buffers_type
> buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = buffers_.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(data_buffers);
>
>
> boost::match_results<iterator,
> typename std::vector<boost::sub_match<iterator> >::allocator_type>
> match_results;
> bool match = regex_search(start_pos, end, match_results, expr_,
> boost::match_default | boost::match_partial);
> if (match && match_results[0].matched)
> {
>
> search_position_ = match_results[0].second - begin;
> bytes_to_read = 0;
> }
>
>
> else if (buffers_.size() == buffers_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
> if (match)
> {
>
>
> search_position_ = match_results[0].first - begin;
> }
> else
> {
>
> search_position_ = end - begin;
> }
>
> bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512,
> buffers_.capacity() - buffers_.size()),
> std::min<std::size_t>(65536,
> buffers_.max_size() - buffers_.size()));
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(buffers_.prepare(bytes_to_read),
> static_cast<read_until_expr_op&&>(*this));
> return; default:
> buffers_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> DynamicBuffer buffers_;
> RegEx expr_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename RegEx, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename RegEx, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename RegEx, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename RegEx, typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename RegEx, typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename RegEx, typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename RegEx, typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_until_expr_op<AsyncReadStream,
> DynamicBuffer, RegEx, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncReadStream,
> typename DynamicBuffer, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> const boost::regex& expr,
> ReadHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_until_expr_op<AsyncReadStream,
> typename decay<DynamicBuffer>::type,
> boost::regex, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> s, static_cast<DynamicBuffer&&>(buffers),
> expr, init.completion_handler)(boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>namespace detail
>{
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler>
> class read_until_match_op
> {
> public:
> template <typename BufferSequence>
> read_until_match_op(AsyncReadStream& stream,
> BufferSequence&& buffers,
> MatchCondition match_condition, ReadHandler& handler)
> : stream_(stream),
> buffers_(static_cast<BufferSequence&&>(buffers)),
> match_condition_(match_condition),
> start_(0),
> search_position_(0),
> handler_(static_cast<ReadHandler&&>(handler))
> {
> }
>
>
> read_until_match_op(const read_until_match_op& other)
> : stream_(other.stream_),
> buffers_(other.buffers_),
> match_condition_(other.match_condition_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(other.handler_)
> {
> }
>
> read_until_match_op(read_until_match_op&& other)
> : stream_(other.stream_),
> buffers_(static_cast<DynamicBuffer&&>(other.buffers_)),
> match_condition_(other.match_condition_),
> start_(other.start_),
> search_position_(other.search_position_),
> handler_(static_cast<ReadHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> const std::size_t not_found = (std::numeric_limits<std::size_t>::max)();
> std::size_t bytes_to_read;
> switch (start_ = start)
> {
> case 1:
> for (;;)
> {
> {
>
> typedef typename DynamicBuffer::const_buffers_type
> buffers_type;
> typedef buffers_iterator<buffers_type> iterator;
> buffers_type data_buffers = buffers_.data();
> iterator begin = iterator::begin(data_buffers);
> iterator start_pos = begin + search_position_;
> iterator end = iterator::end(data_buffers);
>
>
> std::pair<iterator, bool> result = match_condition_(start_pos, end);
> if (result.second)
> {
>
> search_position_ = result.first - begin;
> bytes_to_read = 0;
> }
>
>
> else if (buffers_.size() == buffers_.max_size())
> {
> search_position_ = not_found;
> bytes_to_read = 0;
> }
>
>
> else
> {
> if (result.first != end)
> {
>
>
> search_position_ = result.first - begin;
> }
> else
> {
>
> search_position_ = end - begin;
> }
>
> bytes_to_read = std::min<std::size_t>(
> std::max<std::size_t>(512,
> buffers_.capacity() - buffers_.size()),
> std::min<std::size_t>(65536,
> buffers_.max_size() - buffers_.size()));
> }
> }
>
>
> if (!start && bytes_to_read == 0)
> break;
>
>
> stream_.async_read_some(buffers_.prepare(bytes_to_read),
> static_cast<read_until_match_op&&>(*this));
> return; default:
> buffers_.commit(bytes_transferred);
> if (ec || bytes_transferred == 0)
> break;
> }
>
> const boost::system::error_code result_ec =
> (search_position_ == not_found)
> ? error::not_found : ec;
>
> const std::size_t result_n =
> (ec || search_position_ == not_found)
> ? 0 : search_position_;
>
> handler_(result_ec, result_n);
> }
> }
>
>
> AsyncReadStream& stream_;
> DynamicBuffer buffers_;
> MatchCondition match_condition_;
> int start_;
> std::size_t search_position_;
> ReadHandler handler_;
> };
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler>
> inline void* asio_handler_allocate(std::size_t size,
> read_until_match_op<AsyncReadStream, DynamicBuffer,
> MatchCondition, ReadHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> read_until_match_op<AsyncReadStream, DynamicBuffer,
> MatchCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler>
> inline bool asio_handler_is_continuation(
> read_until_match_op<AsyncReadStream, DynamicBuffer,
> MatchCondition, ReadHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename MatchCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(Function& function,
> read_until_match_op<AsyncReadStream, DynamicBuffer,
> MatchCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncReadStream,
> typename DynamicBuffer, typename MatchCondition,
> typename ReadHandler>
> inline void asio_handler_invoke(const Function& function,
> read_until_match_op<AsyncReadStream, DynamicBuffer,
> MatchCondition, ReadHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>}
>
>
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler, typename Allocator>
>struct associated_allocator<
> detail::read_until_match_op<AsyncReadStream,
> DynamicBuffer, MatchCondition, ReadHandler>,
> Allocator>
>{
> typedef typename associated_allocator<ReadHandler, Allocator>::type type;
>
> static type get(
> const detail::read_until_match_op<AsyncReadStream,
> DynamicBuffer, MatchCondition, ReadHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<ReadHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler, typename Executor>
>struct associated_executor<
> detail::read_until_match_op<AsyncReadStream,
> DynamicBuffer, MatchCondition, ReadHandler>,
> Executor>
>{
> typedef typename associated_executor<ReadHandler, Executor>::type type;
>
> static type get(
> const detail::read_until_match_op<AsyncReadStream,
> DynamicBuffer, MatchCondition, ReadHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<ReadHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncReadStream, typename DynamicBuffer,
> typename MatchCondition, typename ReadHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> DynamicBuffer&& buffers,
> MatchCondition match_condition, ReadHandler&& handler,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::read_until_match_op<AsyncReadStream,
> typename decay<DynamicBuffer>::type,
> MatchCondition, typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> s, static_cast<DynamicBuffer&&>(buffers),
> match_condition, init.completion_handler)(
> boost::system::error_code(), 0, 1);
>
> return init.result.get();
>}
>
>
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> char delim, ReadHandler&& handler)
>{
> return async_read_until(s, basic_streambuf_ref<Allocator>(b),
> delim, static_cast<ReadHandler&&>(handler));
>}
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> boost::asio::string_view delim,
> ReadHandler&& handler)
>{
> return async_read_until(s, basic_streambuf_ref<Allocator>(b),
> delim, static_cast<ReadHandler&&>(handler));
>}
>
>
>
>template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
> ReadHandler&& handler)
>{
> return async_read_until(s, basic_streambuf_ref<Allocator>(b),
> expr, static_cast<ReadHandler&&>(handler));
>}
>
>
>
>template <typename AsyncReadStream, typename Allocator,
> typename MatchCondition, typename ReadHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_read_until(AsyncReadStream& s,
> boost::asio::basic_streambuf<Allocator>& b,
> MatchCondition match_condition, ReadHandler&& handler,
> typename enable_if<is_match_condition<MatchCondition>::value>::type*)
>{
> return async_read_until(s, basic_streambuf_ref<Allocator>(b),
> match_condition, static_cast<ReadHandler&&>(handler));
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1501 "/usr/include/boost/asio/impl/read_until.hpp" 2 3 4
># 1825 "/usr/include/boost/asio/read_until.hpp" 2 3 4
># 114 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/seq_packet_socket_service.hpp" 1 3 4
># 115 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/serial_port.hpp" 1 3 4
># 31 "/usr/include/boost/asio/serial_port.hpp" 3 4
># 1 "/usr/include/boost/asio/serial_port_base.hpp" 1 3 4
># 25 "/usr/include/boost/asio/serial_port_base.hpp" 3 4
># 1 "/usr/include/termios.h" 1 3 4
># 35 "/usr/include/termios.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/termios.h" 1 3 4
># 23 "/usr/include/bits/termios.h" 3 4
>typedef unsigned char cc_t;
>typedef unsigned int speed_t;
>typedef unsigned int tcflag_t;
>
>
>struct termios
> {
> tcflag_t c_iflag;
> tcflag_t c_oflag;
> tcflag_t c_cflag;
> tcflag_t c_lflag;
> cc_t c_line;
> cc_t c_cc[32];
> speed_t c_ispeed;
> speed_t c_ospeed;
>
>
> };
># 40 "/usr/include/termios.h" 2 3 4
># 48 "/usr/include/termios.h" 3 4
>extern speed_t cfgetospeed (const struct termios *__termios_p) throw ();
>
>
>extern speed_t cfgetispeed (const struct termios *__termios_p) throw ();
>
>
>extern int cfsetospeed (struct termios *__termios_p, speed_t __speed) throw ();
>
>
>extern int cfsetispeed (struct termios *__termios_p, speed_t __speed) throw ();
>
>
>
>extern int cfsetspeed (struct termios *__termios_p, speed_t __speed) throw ();
>
>
>
>
>extern int tcgetattr (int __fd, struct termios *__termios_p) throw ();
>
>
>
>extern int tcsetattr (int __fd, int __optional_actions,
> const struct termios *__termios_p) throw ();
>
>
>
>
>extern void cfmakeraw (struct termios *__termios_p) throw ();
>
>
>
>extern int tcsendbreak (int __fd, int __duration) throw ();
>
>
>
>
>
>extern int tcdrain (int __fd);
>
>
>
>extern int tcflush (int __fd, int __queue_selector) throw ();
>
>
>
>extern int tcflow (int __fd, int __action) throw ();
>
>
>
>
>extern __pid_t tcgetsid (int __fd) throw ();
>
>
>
>
># 1 "/usr/include/sys/ttydefaults.h" 1 3 4
># 105 "/usr/include/termios.h" 2 3 4
>
>
>}
># 26 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
># 39 "/usr/include/boost/asio/serial_port_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 40 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>
>class serial_port_base
>{
>public:
>
>
>
>
> class baud_rate
> {
> public:
> explicit baud_rate(unsigned int rate = 0);
> unsigned int value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> unsigned int value_;
> };
>
>
>
>
>
> class flow_control
> {
> public:
> enum type { none, software, hardware };
> inline explicit flow_control(type t = none);
> type value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> type value_;
> };
>
>
>
>
>
> class parity
> {
> public:
> enum type { none, odd, even };
> inline explicit parity(type t = none);
> type value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> type value_;
> };
>
>
>
>
>
> class stop_bits
> {
> public:
> enum type { one, onepointfive, two };
> inline explicit stop_bits(type t = one);
> type value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> type value_;
> };
>
>
>
>
>
> class character_size
> {
> public:
> inline explicit character_size(unsigned int t = 8);
> unsigned int value() const;
> inline boost::system::error_code store(
> termios& storage,
> boost::system::error_code& ec) const;
> inline boost::system::error_code load(
> const termios& storage,
> boost::system::error_code& ec);
> private:
> unsigned int value_;
> };
>
>protected:
>
> ~serial_port_base()
> {
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 158 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/impl/serial_port_base.hpp" 1 3 4
># 19 "/usr/include/boost/asio/impl/serial_port_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 20 "/usr/include/boost/asio/impl/serial_port_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>inline serial_port_base::baud_rate::baud_rate(unsigned int rate)
> : value_(rate)
>{
>}
>
>inline unsigned int serial_port_base::baud_rate::value() const
>{
> return value_;
>}
>
>inline serial_port_base::flow_control::type
>serial_port_base::flow_control::value() const
>{
> return value_;
>}
>
>inline serial_port_base::parity::type serial_port_base::parity::value() const
>{
> return value_;
>}
>
>inline serial_port_base::stop_bits::type
>serial_port_base::stop_bits::value() const
>{
> return value_;
>}
>
>inline unsigned int serial_port_base::character_size::value() const
>{
> return value_;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 60 "/usr/include/boost/asio/impl/serial_port_base.hpp" 2 3 4
># 162 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/serial_port_base.ipp" 1 3 4
># 25 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
># 1 "/usr/include/boost/asio/serial_port_base.hpp" 1 3 4
># 26 "/usr/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
># 36 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 37 "/usr/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>boost::system::error_code serial_port_base::baud_rate::store(
> termios& storage, boost::system::error_code& ec) const
>{
>
>
>
> speed_t baud;
> switch (value_)
> {
>
> case 0: baud = 0000000; break;
> case 50: baud = 0000001; break;
> case 75: baud = 0000002; break;
> case 110: baud = 0000003; break;
> case 134: baud = 0000004; break;
> case 150: baud = 0000005; break;
> case 200: baud = 0000006; break;
> case 300: baud = 0000007; break;
> case 600: baud = 0000010; break;
> case 1200: baud = 0000011; break;
> case 1800: baud = 0000012; break;
> case 2400: baud = 0000013; break;
> case 4800: baud = 0000014; break;
> case 9600: baud = 0000015; break;
> case 19200: baud = 0000016; break;
> case 38400: baud = 0000017; break;
># 75 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> case 57600: baud = 0010001; break;
>
>
> case 115200: baud = 0010002; break;
>
>
> case 230400: baud = 0010003; break;
>
>
> case 460800: baud = 0010004; break;
>
>
> case 500000: baud = 0010005; break;
>
>
> case 576000: baud = 0010006; break;
>
>
> case 921600: baud = 0010007; break;
>
>
> case 1000000: baud = 0010010; break;
>
>
> case 1152000: baud = 0010011; break;
>
>
> case 2000000: baud = 0010013; break;
>
>
> case 3000000: baud = 0010015; break;
>
>
> case 3500000: baud = 0010016; break;
>
>
> case 4000000: baud = 0010017; break;
>
> default:
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> ::cfsetspeed(&storage, baud);
>
>
>
>
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::baud_rate::load(
> const termios& storage, boost::system::error_code& ec)
>{
>
>
>
> speed_t baud = ::cfgetospeed(&storage);
> switch (baud)
> {
>
> case 0000000: value_ = 0; break;
> case 0000001: value_ = 50; break;
> case 0000002: value_ = 75; break;
> case 0000003: value_ = 110; break;
> case 0000004: value_ = 134; break;
> case 0000005: value_ = 150; break;
> case 0000006: value_ = 200; break;
> case 0000007: value_ = 300; break;
> case 0000010: value_ = 600; break;
> case 0000011: value_ = 1200; break;
> case 0000012: value_ = 1800; break;
> case 0000013: value_ = 2400; break;
> case 0000014: value_ = 4800; break;
> case 0000015: value_ = 9600; break;
> case 0000016: value_ = 19200; break;
> case 0000017: value_ = 38400; break;
># 162 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> case 0010001: value_ = 57600; break;
>
>
> case 0010002: value_ = 115200; break;
>
>
> case 0010003: value_ = 230400; break;
>
>
> case 0010004: value_ = 460800; break;
>
>
> case 0010005: value_ = 500000; break;
>
>
> case 0010006: value_ = 576000; break;
>
>
> case 0010007: value_ = 921600; break;
>
>
> case 0010010: value_ = 1000000; break;
>
>
> case 0010011: value_ = 1152000; break;
>
>
> case 0010013: value_ = 2000000; break;
>
>
> case 0010015: value_ = 3000000; break;
>
>
> case 0010016: value_ = 3500000; break;
>
>
> case 0010017: value_ = 4000000; break;
>
> default:
> value_ = 0;
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::flow_control::flow_control(
> serial_port_base::flow_control::type t)
> : value_(t)
>{
> if (t != none && t != software && t != hardware)
> {
> std::out_of_range ex("invalid flow_control value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::flow_control::store(
> termios& storage, boost::system::error_code& ec) const
>{
># 249 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> switch (value_)
> {
> case none:
> storage.c_iflag &= ~(0010000 | 0002000);
>
> storage.c_cflag &= ~020000000000;
>
>
>
> break;
> case software:
> storage.c_iflag |= 0010000 | 0002000;
>
> storage.c_cflag &= ~020000000000;
>
>
>
> break;
> case hardware:
>
> storage.c_iflag &= ~(0010000 | 0002000);
> storage.c_cflag |= 020000000000;
> break;
># 280 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> default:
> break;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::flow_control::load(
> const termios& storage, boost::system::error_code& ec)
>{
># 305 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> if (storage.c_iflag & (0010000 | 0002000))
> {
> value_ = software;
> }
>
> else if (storage.c_cflag & 020000000000)
> {
> value_ = hardware;
> }
>
>
>
>
>
>
> else
> {
> value_ = none;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::parity::parity(serial_port_base::parity::type t)
> : value_(t)
>{
> if (t != none && t != odd && t != even)
> {
> std::out_of_range ex("invalid parity value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::parity::store(
> termios& storage, boost::system::error_code& ec) const
>{
># 361 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> switch (value_)
> {
> case none:
> storage.c_iflag |= 0000004;
> storage.c_cflag &= ~(0000400 | 0001000);
> break;
> case even:
> storage.c_iflag &= ~(0000004 | 0000010);
> storage.c_iflag |= 0000020;
> storage.c_cflag |= 0000400;
> storage.c_cflag &= ~0001000;
> break;
> case odd:
> storage.c_iflag &= ~(0000004 | 0000010);
> storage.c_iflag |= 0000020;
> storage.c_cflag |= (0000400 | 0001000);
> break;
> default:
> break;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::parity::load(
> const termios& storage, boost::system::error_code& ec)
>{
># 403 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> if (storage.c_cflag & 0000400)
> {
> if (storage.c_cflag & 0001000)
> {
> value_ = odd;
> }
> else
> {
> value_ = even;
> }
> }
> else
> {
> value_ = none;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::stop_bits::stop_bits(
> serial_port_base::stop_bits::type t)
> : value_(t)
>{
> if (t != one && t != onepointfive && t != two)
> {
> std::out_of_range ex("invalid stop_bits value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::stop_bits::store(
> termios& storage, boost::system::error_code& ec) const
>{
># 453 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> switch (value_)
> {
> case one:
> storage.c_cflag &= ~0000100;
> break;
> case two:
> storage.c_cflag |= 0000100;
> break;
> default:
> ec = boost::asio::error::operation_not_supported;
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::stop_bits::load(
> const termios& storage, boost::system::error_code& ec)
>{
># 491 "/usr/include/boost/asio/impl/serial_port_base.ipp" 3 4
> value_ = (storage.c_cflag & 0000100) ? two : one;
>
> ec = boost::system::error_code();
> return ec;
>}
>
>serial_port_base::character_size::character_size(unsigned int t)
> : value_(t)
>{
> if (t < 5 || t > 8)
> {
> std::out_of_range ex("invalid character_size value");
> boost::asio::detail::throw_exception(ex);
> }
>}
>
>boost::system::error_code serial_port_base::character_size::store(
> termios& storage, boost::system::error_code& ec) const
>{
>
>
>
> storage.c_cflag &= ~0000060;
> switch (value_)
> {
> case 5: storage.c_cflag |= 0000000; break;
> case 6: storage.c_cflag |= 0000020; break;
> case 7: storage.c_cflag |= 0000040; break;
> case 8: storage.c_cflag |= 0000060; break;
> default: break;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code serial_port_base::character_size::load(
> const termios& storage, boost::system::error_code& ec)
>{
>
>
>
> if ((storage.c_cflag & 0000060) == 0000000) { value_ = 5; }
> else if ((storage.c_cflag & 0000060) == 0000020) { value_ = 6; }
> else if ((storage.c_cflag & 0000060) == 0000040) { value_ = 7; }
> else if ((storage.c_cflag & 0000060) == 0000060) { value_ = 8; }
> else
> {
>
> value_ = 8;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 551 "/usr/include/boost/asio/impl/serial_port_base.ipp" 2 3 4
># 164 "/usr/include/boost/asio/serial_port_base.hpp" 2 3 4
># 32 "/usr/include/boost/asio/serial_port.hpp" 2 3 4
># 44 "/usr/include/boost/asio/serial_port.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 1 3 4
># 31 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 32 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class reactive_serial_port_service :
> public service_base<reactive_serial_port_service>
>{
>public:
>
> typedef reactive_descriptor_service::native_handle_type native_handle_type;
>
>
> typedef reactive_descriptor_service::implementation_type implementation_type;
>
> inline reactive_serial_port_service(
> boost::asio::io_context& io_context);
>
>
> inline void shutdown();
>
>
> void construct(implementation_type& impl)
> {
> descriptor_service_.construct(impl);
> }
>
>
> void move_construct(implementation_type& impl,
> implementation_type& other_impl)
> {
> descriptor_service_.move_construct(impl, other_impl);
> }
>
>
> void move_assign(implementation_type& impl,
> reactive_serial_port_service& other_service,
> implementation_type& other_impl)
> {
> descriptor_service_.move_assign(impl,
> other_service.descriptor_service_, other_impl);
> }
>
>
> void destroy(implementation_type& impl)
> {
> descriptor_service_.destroy(impl);
> }
>
>
> inline boost::system::error_code open(implementation_type& impl,
> const std::string& device, boost::system::error_code& ec);
>
>
> boost::system::error_code assign(implementation_type& impl,
> const native_handle_type& native_descriptor,
> boost::system::error_code& ec)
> {
> return descriptor_service_.assign(impl, native_descriptor, ec);
> }
>
>
> bool is_open(const implementation_type& impl) const
> {
> return descriptor_service_.is_open(impl);
> }
>
>
> boost::system::error_code close(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return descriptor_service_.close(impl, ec);
> }
>
>
> native_handle_type native_handle(implementation_type& impl)
> {
> return descriptor_service_.native_handle(impl);
> }
>
>
> boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec)
> {
> return descriptor_service_.cancel(impl, ec);
> }
>
>
> template <typename SettableSerialPortOption>
> boost::system::error_code set_option(implementation_type& impl,
> const SettableSerialPortOption& option, boost::system::error_code& ec)
> {
> return do_set_option(impl,
> &reactive_serial_port_service::store_option<SettableSerialPortOption>,
> &option, ec);
> }
>
>
> template <typename GettableSerialPortOption>
> boost::system::error_code get_option(const implementation_type& impl,
> GettableSerialPortOption& option, boost::system::error_code& ec) const
> {
> return do_get_option(impl,
> &reactive_serial_port_service::load_option<GettableSerialPortOption>,
> &option, ec);
> }
>
>
> boost::system::error_code send_break(implementation_type& impl,
> boost::system::error_code& ec)
> {
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcsendbreak(
> descriptor_service_.native_handle(impl), 0), ec);
> return ec;
> }
>
>
> template <typename ConstBufferSequence>
> size_t write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> return descriptor_service_.write_some(impl, buffers, ec);
> }
>
>
>
> template <typename ConstBufferSequence, typename Handler>
> void async_write_some(implementation_type& impl,
> const ConstBufferSequence& buffers, Handler& handler)
> {
> descriptor_service_.async_write_some(impl, buffers, handler);
> }
>
>
> template <typename MutableBufferSequence>
> size_t read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, boost::system::error_code& ec)
> {
> return descriptor_service_.read_some(impl, buffers, ec);
> }
>
>
>
> template <typename MutableBufferSequence, typename Handler>
> void async_read_some(implementation_type& impl,
> const MutableBufferSequence& buffers, Handler& handler)
> {
> descriptor_service_.async_read_some(impl, buffers, handler);
> }
>
>private:
>
> typedef boost::system::error_code (*store_function_type)(
> const void*, termios&, boost::system::error_code&);
>
>
> template <typename SettableSerialPortOption>
> static boost::system::error_code store_option(const void* option,
> termios& storage, boost::system::error_code& ec)
> {
> static_cast<const SettableSerialPortOption*>(option)->store(storage, ec);
> return ec;
> }
>
>
> inline boost::system::error_code do_set_option(
> implementation_type& impl, store_function_type store,
> const void* option, boost::system::error_code& ec);
>
>
> typedef boost::system::error_code (*load_function_type)(
> void*, const termios&, boost::system::error_code&);
>
>
> template <typename GettableSerialPortOption>
> static boost::system::error_code load_option(void* option,
> const termios& storage, boost::system::error_code& ec)
> {
> static_cast<GettableSerialPortOption*>(option)->load(storage, ec);
> return ec;
> }
>
>
> inline boost::system::error_code do_get_option(
> const implementation_type& impl, load_function_type load,
> void* option, boost::system::error_code& ec) const;
>
>
> reactive_descriptor_service descriptor_service_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 230 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 25 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 1 3 4
># 26 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>reactive_serial_port_service::reactive_serial_port_service(
> boost::asio::io_context& io_context)
> : service_base<reactive_serial_port_service>(io_context),
> descriptor_service_(io_context)
>{
>}
>
>void reactive_serial_port_service::shutdown()
>{
> descriptor_service_.shutdown();
>}
>
>boost::system::error_code reactive_serial_port_service::open(
> reactive_serial_port_service::implementation_type& impl,
> const std::string& device, boost::system::error_code& ec)
>{
> if (is_open(impl))
> {
> ec = boost::asio::error::already_open;
> return ec;
> }
>
> descriptor_ops::state_type state = 0;
> int fd = descriptor_ops::open(device.c_str(),
> 02 | 04000 | 0400, ec);
> if (fd < 0)
> return ec;
>
> int s = descriptor_ops::fcntl(fd, 3, ec);
> if (s >= 0)
> s = descriptor_ops::fcntl(fd, 4, s | 04000, ec);
> if (s < 0)
> {
> boost::system::error_code ignored_ec;
> descriptor_ops::close(fd, state, ignored_ec);
> return ec;
> }
>
>
> termios ios;
> (*__errno_location ()) = 0;
> s = descriptor_ops::error_wrapper(::tcgetattr(fd, &ios), ec);
> if (s >= 0)
> {
>
> ::cfmakeraw(&ios);
># 87 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 3 4
> ios.c_iflag |= 0000004;
> ios.c_cflag |= 0000200 | 0004000;
> (*__errno_location ()) = 0;
> s = descriptor_ops::error_wrapper(::tcsetattr(fd, 0, &ios), ec);
> }
> if (s < 0)
> {
> boost::system::error_code ignored_ec;
> descriptor_ops::close(fd, state, ignored_ec);
> return ec;
> }
>
>
> if (descriptor_service_.assign(impl, fd, ec))
> {
> boost::system::error_code ignored_ec;
> descriptor_ops::close(fd, state, ignored_ec);
> }
>
> return ec;
>}
>
>boost::system::error_code reactive_serial_port_service::do_set_option(
> reactive_serial_port_service::implementation_type& impl,
> reactive_serial_port_service::store_function_type store,
> const void* option, boost::system::error_code& ec)
>{
> termios ios;
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcgetattr(
> descriptor_service_.native_handle(impl), &ios), ec);
> if (ec)
> return ec;
>
> if (store(option, ios, ec))
> return ec;
>
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcsetattr(
> descriptor_service_.native_handle(impl), 0, &ios), ec);
> return ec;
>}
>
>boost::system::error_code reactive_serial_port_service::do_get_option(
> const reactive_serial_port_service::implementation_type& impl,
> reactive_serial_port_service::load_function_type load,
> void* option, boost::system::error_code& ec) const
>{
> termios ios;
> (*__errno_location ()) = 0;
> descriptor_ops::error_wrapper(::tcgetattr(
> descriptor_service_.native_handle(impl), &ios), ec);
> if (ec)
> return ec;
>
> return load(option, ios, ec);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 150 "/usr/include/boost/asio/detail/impl/reactive_serial_port_service.ipp" 2 3 4
># 233 "/usr/include/boost/asio/detail/reactive_serial_port_service.hpp" 2 3 4
># 45 "/usr/include/boost/asio/serial_port.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 50 "/usr/include/boost/asio/serial_port.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 66 "/usr/include/boost/asio/serial_port.hpp" 3 4
>class serial_port
> : protected basic_io_object<detail::reactive_serial_port_service>,
> public serial_port_base
>{
>public:
>
> typedef io_context::executor_type executor_type;
>
>
>
>
>
> typedef detail::reactive_serial_port_service::native_handle_type native_handle_type;
>
>
>
> typedef serial_port lowest_layer_type;
># 91 "/usr/include/boost/asio/serial_port.hpp" 3 4
> explicit serial_port(boost::asio::io_context& io_context)
> : basic_io_object<detail::reactive_serial_port_service>(io_context)
> {
> }
># 107 "/usr/include/boost/asio/serial_port.hpp" 3 4
> explicit serial_port(boost::asio::io_context& io_context,
> const char* device)
> : basic_io_object<detail::reactive_serial_port_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), device, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 127 "/usr/include/boost/asio/serial_port.hpp" 3 4
> explicit serial_port(boost::asio::io_context& io_context,
> const std::string& device)
> : basic_io_object<detail::reactive_serial_port_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), device, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 148 "/usr/include/boost/asio/serial_port.hpp" 3 4
> serial_port(boost::asio::io_context& io_context,
> const native_handle_type& native_serial_port)
> : basic_io_object<detail::reactive_serial_port_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_serial_port, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 169 "/usr/include/boost/asio/serial_port.hpp" 3 4
> serial_port(serial_port&& other)
> : basic_io_object<detail::reactive_serial_port_service>(std::move(other))
> {
> }
># 184 "/usr/include/boost/asio/serial_port.hpp" 3 4
> serial_port& operator=(serial_port&& other)
> {
> basic_io_object<detail::reactive_serial_port_service>::operator=(std::move(other));
> return *this;
> }
># 197 "/usr/include/boost/asio/serial_port.hpp" 3 4
> ~serial_port()
> {
> }
># 211 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<detail::reactive_serial_port_service>::get_io_context();
> }
># 225 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<detail::reactive_serial_port_service>::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<detail::reactive_serial_port_service>::get_executor();
> }
># 246 "/usr/include/boost/asio/serial_port.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return *this;
> }
># 260 "/usr/include/boost/asio/serial_port.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return *this;
> }
># 273 "/usr/include/boost/asio/serial_port.hpp" 3 4
> void open(const std::string& device)
> {
> boost::system::error_code ec;
> this->get_service().open(this->get_implementation(), device, ec);
> boost::asio::detail::throw_error(ec, "open");
> }
># 289 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::system::error_code open(const std::string& device,
> boost::system::error_code& ec)
> {
> this->get_service().open(this->get_implementation(), device, ec);
> return ec;
> }
># 304 "/usr/include/boost/asio/serial_port.hpp" 3 4
> void assign(const native_handle_type& native_serial_port)
> {
> boost::system::error_code ec;
> this->get_service().assign(this->get_implementation(),
> native_serial_port, ec);
> boost::asio::detail::throw_error(ec, "assign");
> }
># 320 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::system::error_code assign(const native_handle_type& native_serial_port,
> boost::system::error_code& ec)
> {
> this->get_service().assign(this->get_implementation(),
> native_serial_port, ec);
> return ec;
> }
>
>
> bool is_open() const
> {
> return this->get_service().is_open(this->get_implementation());
> }
># 342 "/usr/include/boost/asio/serial_port.hpp" 3 4
> void close()
> {
> boost::system::error_code ec;
> this->get_service().close(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "close");
> }
># 357 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::system::error_code close(boost::system::error_code& ec)
> {
> this->get_service().close(this->get_implementation(), ec);
> return ec;
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return this->get_service().native_handle(this->get_implementation());
> }
># 382 "/usr/include/boost/asio/serial_port.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 397 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> this->get_service().cancel(this->get_implementation(), ec);
> return ec;
> }
># 410 "/usr/include/boost/asio/serial_port.hpp" 3 4
> void send_break()
> {
> boost::system::error_code ec;
> this->get_service().send_break(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "send_break");
> }
># 424 "/usr/include/boost/asio/serial_port.hpp" 3 4
> boost::system::error_code send_break(boost::system::error_code& ec)
> {
> this->get_service().send_break(this->get_implementation(), ec);
> return ec;
> }
># 445 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename SettableSerialPortOption>
> void set_option(const SettableSerialPortOption& option)
> {
> boost::system::error_code ec;
> this->get_service().set_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "set_option");
> }
># 468 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename SettableSerialPortOption>
> boost::system::error_code set_option(const SettableSerialPortOption& option,
> boost::system::error_code& ec)
> {
> this->get_service().set_option(this->get_implementation(), option, ec);
> return ec;
> }
># 492 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename GettableSerialPortOption>
> void get_option(GettableSerialPortOption& option)
> {
> boost::system::error_code ec;
> this->get_service().get_option(this->get_implementation(), option, ec);
> boost::asio::detail::throw_error(ec, "get_option");
> }
># 516 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename GettableSerialPortOption>
> boost::system::error_code get_option(GettableSerialPortOption& option,
> boost::system::error_code& ec)
> {
> this->get_service().get_option(this->get_implementation(), option, ec);
> return ec;
> }
># 551 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return s;
> }
># 577 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().write_some(
> this->get_implementation(), buffers, ec);
> }
># 620 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_write_some(
> this->get_implementation(), buffers, init.completion_handler);
>
> return init.result.get();
> }
># 667 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t s = this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return s;
> }
># 694 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return this->get_service().read_some(
> this->get_implementation(), buffers, ec);
> }
># 738 "/usr/include/boost/asio/serial_port.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> this->get_service().async_read_some(
> this->get_implementation(), buffers, init.completion_handler);
>
> return init.result.get();
> }
>};
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 763 "/usr/include/boost/asio/serial_port.hpp" 2 3 4
># 116 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/serial_port_service.hpp" 1 3 4
># 118 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/signal_set.hpp" 1 3 4
># 30 "/usr/include/boost/asio/signal_set.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/signal_set_service.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/signal_set_service.hpp" 3 4
># 1 "/usr/include/signal.h" 1 3 4
># 27 "/usr/include/signal.h" 3 4
>extern "C" {
>
>
># 1 "/usr/include/bits/signum.h" 1 3 4
># 26 "/usr/include/bits/signum.h" 3 4
># 1 "/usr/include/bits/signum-generic.h" 1 3 4
># 27 "/usr/include/bits/signum.h" 2 3 4
># 31 "/usr/include/signal.h" 2 3 4
>
># 1 "/usr/include/bits/types/sig_atomic_t.h" 1 3 4
>
>
>
>
>
>
>
>typedef __sig_atomic_t sig_atomic_t;
># 33 "/usr/include/signal.h" 2 3 4
># 57 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/types/siginfo_t.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/bits/types/siginfo_t.h" 2 3 4
># 16 "/usr/include/bits/types/siginfo_t.h" 3 4
># 1 "/usr/include/bits/siginfo-arch.h" 1 3 4
># 17 "/usr/include/bits/types/siginfo_t.h" 2 3 4
># 36 "/usr/include/bits/types/siginfo_t.h" 3 4
>typedef struct
> {
> int si_signo;
>
> int si_errno;
>
> int si_code;
>
>
>
>
>
> int __pad0;
>
>
> union
> {
> int _pad[((128 / sizeof (int)) - 4)];
>
>
> struct
> {
> __pid_t si_pid;
> __uid_t si_uid;
> } _kill;
>
>
> struct
> {
> int si_tid;
> int si_overrun;
> __sigval_t si_sigval;
> } _timer;
>
>
> struct
> {
> __pid_t si_pid;
> __uid_t si_uid;
> __sigval_t si_sigval;
> } _rt;
>
>
> struct
> {
> __pid_t si_pid;
> __uid_t si_uid;
> int si_status;
> __clock_t si_utime;
> __clock_t si_stime;
> } _sigchld;
>
>
> struct
> {
> void *si_addr;
> 
> short int si_addr_lsb;
> union
> {
>
> struct
> {
> void *_lower;
> void *_upper;
> } _addr_bnd;
>
> __uint32_t _pkey;
> } _bounds;
> } _sigfault;
>
>
> struct
> {
> long int si_band;
> int si_fd;
> } _sigpoll;
>
>
>
> struct
> {
> void *_call_addr;
> int _syscall;
> unsigned int _arch;
> } _sigsys;
>
> } _sifields;
> } siginfo_t ;
># 58 "/usr/include/signal.h" 2 3 4
># 1 "/usr/include/bits/siginfo-consts.h" 1 3 4
># 35 "/usr/include/bits/siginfo-consts.h" 3 4
>enum
>{
> SI_ASYNCNL = -60,
> SI_TKILL = -6,
> SI_SIGIO,
>
> SI_ASYNCIO,
> SI_MESGQ,
> SI_TIMER,
>
>
>
>
>
> SI_QUEUE,
> SI_USER,
> SI_KERNEL = 0x80
># 63 "/usr/include/bits/siginfo-consts.h" 3 4
>};
>
>
>
>
>enum
>{
> ILL_ILLOPC = 1,
>
> ILL_ILLOPN,
>
> ILL_ILLADR,
>
> ILL_ILLTRP,
>
> ILL_PRVOPC,
>
> ILL_PRVREG,
>
> ILL_COPROC,
>
> ILL_BADSTK
>
>};
>
>
>enum
>{
> FPE_INTDIV = 1,
>
> FPE_INTOVF,
>
> FPE_FLTDIV,
>
> FPE_FLTOVF,
>
> FPE_FLTUND,
>
> FPE_FLTRES,
>
> FPE_FLTINV,
>
> FPE_FLTSUB
>
>};
>
>
>enum
>{
> SEGV_MAPERR = 1,
>
> SEGV_ACCERR,
>
> SEGV_BNDERR,
>
> SEGV_PKUERR
>
>};
>
>
>enum
>{
> BUS_ADRALN = 1,
>
> BUS_ADRERR,
>
> BUS_OBJERR,
>
> BUS_MCEERR_AR,
>
> BUS_MCEERR_AO
>
>};
>
>
>
>
>enum
>{
> TRAP_BRKPT = 1,
>
> TRAP_TRACE
>
>};
>
>
>
>
>enum
>{
> CLD_EXITED = 1,
>
> CLD_KILLED,
>
> CLD_DUMPED,
>
> CLD_TRAPPED,
>
> CLD_STOPPED,
>
> CLD_CONTINUED
>
>};
>
>
>enum
>{
> POLL_IN = 1,
>
> POLL_OUT,
>
> POLL_MSG,
>
> POLL_ERR,
>
> POLL_PRI,
>
> POLL_HUP
>
>};
>
>
>
>
>
># 1 "/usr/include/bits/siginfo-consts-arch.h" 1 3 4
># 189 "/usr/include/bits/siginfo-consts.h" 2 3 4
># 59 "/usr/include/signal.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/types/sigval_t.h" 1 3 4
># 16 "/usr/include/bits/types/sigval_t.h" 3 4
>typedef __sigval_t sigval_t;
># 63 "/usr/include/signal.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/sigevent-consts.h" 1 3 4
># 27 "/usr/include/bits/sigevent-consts.h" 3 4
>enum
>{
> SIGEV_SIGNAL = 0,
>
> SIGEV_NONE,
>
> SIGEV_THREAD,
>
>
> SIGEV_THREAD_ID = 4
>
>
>};
># 68 "/usr/include/signal.h" 2 3 4
>
>
>
>
>typedef void (*__sighandler_t) (int);
>
>
>
>
>extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
> throw ();
>
>extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
> throw ();
>
>
>
>
>
>
>extern __sighandler_t signal (int __sig, __sighandler_t __handler)
> throw ();
># 112 "/usr/include/signal.h" 3 4
>extern int kill (__pid_t __pid, int __sig) throw ();
>
>
>
>
>
>
>extern int killpg (__pid_t __pgrp, int __sig) throw ();
>
>
>
>extern int raise (int __sig) throw ();
>
>
>
>extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
> throw ();
>extern int gsignal (int __sig) throw ();
>
>
>
>
>extern void psignal (int __sig, const char *__s);
>
>
>extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
># 151 "/usr/include/signal.h" 3 4
>extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
># 170 "/usr/include/signal.h" 3 4
>extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
>
>
>extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
>
>
>extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
># 185 "/usr/include/signal.h" 3 4
>typedef __sighandler_t sighandler_t;
>
>
>
>
>typedef __sighandler_t sig_t;
>
>
>
>
>
>extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigismember (const sigset_t *__set, int __signo)
> throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigandset (sigset_t *__set, const sigset_t *__left,
> const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>extern int sigorset (sigset_t *__set, const sigset_t *__left,
> const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
>
>
>
>
># 1 "/usr/include/bits/sigaction.h" 1 3 4
># 24 "/usr/include/bits/sigaction.h" 3 4
>struct sigaction
> {
>
>
> union
> {
>
> __sighandler_t sa_handler;
>
> void (*sa_sigaction) (int, siginfo_t *, void *);
> }
> __sigaction_handler;
>
>
>
>
>
>
>
> __sigset_t sa_mask;
>
>
> int sa_flags;
>
>
> void (*sa_restorer) (void);
> };
># 227 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigprocmask (int __how, const sigset_t *__restrict __set,
> sigset_t *__restrict __oset) throw ();
>
>
>
>
>
>
>extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaction (int __sig, const struct sigaction *__restrict __act,
> struct sigaction *__restrict __oact) throw ();
>
>
>extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>
>extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
> __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>
>extern int sigwaitinfo (const sigset_t *__restrict __set,
> siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigtimedwait (const sigset_t *__restrict __set,
> siginfo_t *__restrict __info,
> const struct timespec *__restrict __timeout)
> __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
> throw ();
># 286 "/usr/include/signal.h" 3 4
>extern const char *const _sys_siglist[(64 + 1)];
>extern const char *const sys_siglist[(64 + 1)];
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 31 "/usr/include/bits/sigcontext.h" 3 4
>struct _fpx_sw_bytes
>{
> __uint32_t magic1;
> __uint32_t extended_size;
> __uint64_t xstate_bv;
> __uint32_t xstate_size;
> __uint32_t __glibc_reserved1[7];
>};
>
>struct _fpreg
>{
> unsigned short significand[4];
> unsigned short exponent;
>};
>
>struct _fpxreg
>{
> unsigned short significand[4];
> unsigned short exponent;
> unsigned short __glibc_reserved1[3];
>};
>
>struct _xmmreg
>{
> __uint32_t element[4];
>};
># 123 "/usr/include/bits/sigcontext.h" 3 4
>struct _fpstate
>{
>
> __uint16_t cwd;
> __uint16_t swd;
> __uint16_t ftw;
> __uint16_t fop;
> __uint64_t rip;
> __uint64_t rdp;
> __uint32_t mxcsr;
> __uint32_t mxcr_mask;
> struct _fpxreg _st[8];
> struct _xmmreg _xmm[16];
> __uint32_t __glibc_reserved1[24];
>};
>
>struct sigcontext
>{
> __uint64_t r8;
> __uint64_t r9;
> __uint64_t r10;
> __uint64_t r11;
> __uint64_t r12;
> __uint64_t r13;
> __uint64_t r14;
> __uint64_t r15;
> __uint64_t rdi;
> __uint64_t rsi;
> __uint64_t rbp;
> __uint64_t rbx;
> __uint64_t rdx;
> __uint64_t rax;
> __uint64_t rcx;
> __uint64_t rsp;
> __uint64_t rip;
> __uint64_t eflags;
> unsigned short cs;
> unsigned short gs;
> unsigned short fs;
> unsigned short __pad0;
> __uint64_t err;
> __uint64_t trapno;
> __uint64_t oldmask;
> __uint64_t cr2;
> __extension__ union
> {
> struct _fpstate * fpstate;
> __uint64_t __fpstate_word;
> };
> __uint64_t __reserved1 [8];
>};
>
>
>
>struct _xsave_hdr
>{
> __uint64_t xstate_bv;
> __uint64_t __glibc_reserved1[2];
> __uint64_t __glibc_reserved2[5];
>};
>
>struct _ymmh_state
>{
> __uint32_t ymmh_space[64];
>};
>
>struct _xstate
>{
> struct _fpstate fpstate;
> struct _xsave_hdr xstate_hdr;
> struct _ymmh_state ymmh;
>};
># 292 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigreturn (struct sigcontext *__scp) throw ();
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 302 "/usr/include/signal.h" 2 3 4
>
># 1 "/usr/include/bits/types/stack_t.h" 1 3 4
># 23 "/usr/include/bits/types/stack_t.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 24 "/usr/include/bits/types/stack_t.h" 2 3 4
>
>
>typedef struct
> {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
> } stack_t;
># 304 "/usr/include/signal.h" 2 3 4
>
>
># 1 "/usr/include/sys/ucontext.h" 1 3 4
># 37 "/usr/include/sys/ucontext.h" 3 4
>__extension__ typedef long long int greg_t;
># 46 "/usr/include/sys/ucontext.h" 3 4
>typedef greg_t gregset_t[23];
>
>
>
>enum
>{
> REG_R8 = 0,
>
> REG_R9,
>
> REG_R10,
>
> REG_R11,
>
> REG_R12,
>
> REG_R13,
>
> REG_R14,
>
> REG_R15,
>
> REG_RDI,
>
> REG_RSI,
>
> REG_RBP,
>
> REG_RBX,
>
> REG_RDX,
>
> REG_RAX,
>
> REG_RCX,
>
> REG_RSP,
>
> REG_RIP,
>
> REG_EFL,
>
> REG_CSGSFS,
>
> REG_ERR,
>
> REG_TRAPNO,
>
> REG_OLDMASK,
>
> REG_CR2
>
>};
>
>
>struct _libc_fpxreg
>{
> unsigned short int significand[4];
> unsigned short int exponent;
> unsigned short int __glibc_reserved1[3];
>};
>
>struct _libc_xmmreg
>{
> __uint32_t element[4];
>};
>
>struct _libc_fpstate
>{
>
> __uint16_t cwd;
> __uint16_t swd;
> __uint16_t ftw;
> __uint16_t fop;
> __uint64_t rip;
> __uint64_t rdp;
> __uint32_t mxcsr;
> __uint32_t mxcr_mask;
> struct _libc_fpxreg _st[8];
> struct _libc_xmmreg _xmm[16];
> __uint32_t __glibc_reserved1[24];
>};
>
>
>typedef struct _libc_fpstate *fpregset_t;
>
>
>typedef struct
> {
> gregset_t gregs;
>
> fpregset_t fpregs;
> __extension__ unsigned long long __reserved1 [8];
>} mcontext_t;
>
>
>typedef struct ucontext_t
> {
> unsigned long int uc_flags;
> struct ucontext_t *uc_link;
> stack_t uc_stack;
> mcontext_t uc_mcontext;
> sigset_t uc_sigmask;
> struct _libc_fpstate __fpregs_mem;
> } ucontext_t;
># 307 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>extern int siginterrupt (int __sig, int __interrupt) throw ();
>
># 1 "/usr/include/bits/sigstack.h" 1 3 4
># 317 "/usr/include/signal.h" 2 3 4
># 1 "/usr/include/bits/ss_flags.h" 1 3 4
># 27 "/usr/include/bits/ss_flags.h" 3 4
>enum
>{
> SS_ONSTACK = 1,
>
> SS_DISABLE
>
>};
># 318 "/usr/include/signal.h" 2 3 4
>
>
>
>extern int sigaltstack (const stack_t *__restrict __ss,
> stack_t *__restrict __oss) throw ();
>
>
>
>
># 1 "/usr/include/bits/types/struct_sigstack.h" 1 3 4
># 23 "/usr/include/bits/types/struct_sigstack.h" 3 4
>struct sigstack
> {
> void *ss_sp;
> int ss_onstack;
> };
># 328 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
> throw () __attribute__ ((__deprecated__));
>
>
>
>
>
>
>extern int sighold (int __sig) throw ();
>
>
>extern int sigrelse (int __sig) throw ();
>
>
>extern int sigignore (int __sig) throw ();
>
>
>extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
>
>
>
>
>
>
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 31 "/usr/include/bits/sigthread.h" 3 4
>extern int pthread_sigmask (int __how,
> const __sigset_t *__restrict __newmask,
> __sigset_t *__restrict __oldmask)throw ();
>
>
>extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
>
>
>
>extern int pthread_sigqueue (pthread_t __threadid, int __signo,
> const union sigval __value) throw ();
># 360 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>extern int __libc_current_sigrtmin (void) throw ();
>
>extern int __libc_current_sigrtmax (void) throw ();
>
>
>
>
>}
># 22 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/signal_handler.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/signal_handler.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/signal_op.hpp" 1 3 4
># 21 "/usr/include/boost/asio/detail/signal_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/signal_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class signal_op
> : public operation
>{
>public:
>
> boost::system::error_code ec_;
>
>
> int signal_number_;
>
>protected:
> signal_op(func_type func)
> : operation(func),
> signal_number_(0)
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 50 "/usr/include/boost/asio/detail/signal_op.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/signal_handler.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/signal_handler.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Handler>
>class signal_handler : public signal_op
>{
>public:
> struct ptr { Handler* h; signal_handler* v; signal_handler* p; ~ptr() { reset(); } static signal_handler* allocate(Handler& handler) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<signal_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( handler, ::boost::asio::get_associated_allocator(handler))); return a.allocate(1); } void reset() { if (p) { p->~signal_handler(); p = 0; } if (v) { typedef typename ::boost::asio::associated_allocator< Handler>::type associated_allocator_type; typedef typename ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::type hook_allocator_type; typename std::allocator_traits<hook_allocator_type>::template rebind_alloc<signal_handler> a( ::boost::asio::detail::get_hook_allocator< Handler, associated_allocator_type>::get( *h, ::boost::asio::get_associated_allocator(*h))); a.deallocate(static_cast<signal_handler*>(v), 1); v = 0; } } };
>
> signal_handler(Handler& h)
> : signal_op(&signal_handler::do_complete),
> handler_(static_cast<Handler&&>(h))
> {
> handler_work<Handler>::start(handler_);
> }
>
> static void do_complete(void* owner, operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
>
> signal_handler* h(static_cast<signal_handler*>(base));
> ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
> handler_work<Handler> w(h->handler_);
>
> (void)0;
>
>
>
>
>
>
>
> detail::binder2<Handler, boost::system::error_code, int>
> handler(h->handler_, h->ec_, h->signal_number_);
> p.h = boost::asio::detail::addressof(handler.handler_);
> p.reset();
>
>
> if (owner)
> {
> fenced_block b(fenced_block::half);
> (void)0;
> w.complete(handler, handler.handler_);
> (void)0;
> }
> }
>
>private:
> Handler handler_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 87 "/usr/include/boost/asio/detail/signal_handler.hpp" 2 3 4
># 28 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>
>
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 36 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>enum { max_signal_number = (64 + 1) };
>
>
>
>
>extern inline struct signal_state* get_signal_state();
>
>extern "C" inline void boost_asio_signal_handler(int signal_number);
>
>class signal_set_service :
> public service_base<signal_set_service>
>{
>public:
>
> class registration
> {
> public:
>
> registration()
> : signal_number_(0),
> queue_(0),
> undelivered_(0),
> next_in_table_(0),
> prev_in_table_(0),
> next_in_set_(0)
> {
> }
>
> private:
>
> friend class signal_set_service;
>
>
> int signal_number_;
>
>
> op_queue<signal_op>* queue_;
>
>
> std::size_t undelivered_;
>
>
> registration* next_in_table_;
> registration* prev_in_table_;
>
>
> registration* next_in_set_;
> };
>
>
> class implementation_type
> {
> public:
>
> implementation_type()
> : signals_(0)
> {
> }
>
> private:
>
> friend class signal_set_service;
>
>
> op_queue<signal_op> queue_;
>
>
> registration* signals_;
> };
>
>
> inline signal_set_service(boost::asio::io_context& io_context);
>
>
> inline ~signal_set_service();
>
>
> inline void shutdown();
>
>
> inline void notify_fork(
> boost::asio::io_context::fork_event fork_ev);
>
>
> inline void construct(implementation_type& impl);
>
>
> inline void destroy(implementation_type& impl);
>
>
> inline boost::system::error_code add(implementation_type& impl,
> int signal_number, boost::system::error_code& ec);
>
>
> inline boost::system::error_code remove(implementation_type& impl,
> int signal_number, boost::system::error_code& ec);
>
>
> inline boost::system::error_code clear(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> inline boost::system::error_code cancel(implementation_type& impl,
> boost::system::error_code& ec);
>
>
> template <typename Handler>
> void async_wait(implementation_type& impl, Handler& handler)
> {
>
> typedef signal_handler<Handler> op;
> typename op::ptr p = { boost::asio::detail::addressof(handler),
> op::ptr::allocate(handler), 0 };
> p.p = new (p.v) op(handler);
>
> (void)0
> ;
>
> start_wait_op(impl, p.p);
> p.v = p.p = 0;
> }
>
>
> inline static void deliver_signal(int signal_number);
>
>private:
>
> inline static void add_service(signal_set_service* service);
>
>
> inline static void remove_service(signal_set_service* service);
>
>
> inline static void open_descriptors();
>
>
> inline static void close_descriptors();
>
>
> inline void start_wait_op(implementation_type& impl, signal_op* op);
>
>
> io_context_impl& io_context_;
>
>
>
>
>
> class pipe_read_op;
>
>
> reactor& reactor_;
>
>
> reactor::per_descriptor_data reactor_data_;
>
>
>
>
>
> registration* registrations_[max_signal_number];
>
>
> signal_set_service* next_;
> signal_set_service* prev_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 214 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 21 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/signal_blocker.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/signal_blocker.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 1 3 4
># 22 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 3 4
># 1 "/usr/include/c++/8/csignal" 1 3 4
># 39 "/usr/include/c++/8/csignal" 3 4
> 
># 40 "/usr/include/c++/8/csignal" 3
># 50 "/usr/include/c++/8/csignal" 3
>namespace std
>{
> using ::sig_atomic_t;
> using ::signal;
> using ::raise;
>}
># 23 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>class posix_signal_blocker
> : private noncopyable
>{
>public:
>
> posix_signal_blocker()
> : blocked_(false)
> {
> sigset_t new_mask;
> sigfillset(&new_mask);
> blocked_ = (pthread_sigmask(0, &new_mask, &old_mask_) == 0);
> }
>
>
> ~posix_signal_blocker()
> {
> if (blocked_)
> pthread_sigmask(2, &old_mask_, 0);
> }
>
>
> void block()
> {
> if (!blocked_)
> {
> sigset_t new_mask;
> sigfillset(&new_mask);
> blocked_ = (pthread_sigmask(0, &new_mask, &old_mask_) == 0);
> }
> }
>
>
> void unblock()
> {
> if (blocked_)
> blocked_ = (pthread_sigmask(2, &old_mask_, 0) != 0);
> }
>
>private:
>
> bool blocked_;
>
>
> sigset_t old_mask_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 84 "/usr/include/boost/asio/detail/posix_signal_blocker.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/signal_blocker.hpp" 2 3 4
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>
>
>
>typedef posix_signal_blocker signal_blocker;
>
>
>}
>}
>}
># 24 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/signal_set_service.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
># 1 "/usr/include/boost/asio/detail/static_mutex.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/static_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 1 3 4
># 25 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 26 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct posix_static_mutex
>{
> typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
>
>
> void init()
> {
>
> }
>
>
> void lock()
> {
> (void)::pthread_mutex_lock(&mutex_);
> }
>
>
> void unlock()
> {
> (void)::pthread_mutex_unlock(&mutex_);
> }
>
> ::pthread_mutex_t mutex_;
>};
>
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 63 "/usr/include/boost/asio/detail/posix_static_mutex.hpp" 2 3 4
># 26 "/usr/include/boost/asio/detail/static_mutex.hpp" 2 3 4
>
>
>
>
>
>
>namespace boost {
>namespace asio {
>namespace detail {
># 43 "/usr/include/boost/asio/detail/static_mutex.hpp" 3 4
>typedef posix_static_mutex static_mutex;
>
>
>
>
>
>
>}
>}
>}
># 26 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>struct signal_state
>{
>
> static_mutex mutex_;
>
>
> int read_descriptor_;
>
>
> int write_descriptor_;
>
>
> bool fork_prepared_;
>
>
> class signal_set_service* service_list_;
>
>
> std::size_t registration_count_[max_signal_number];
>};
>
>signal_state* get_signal_state()
>{
> static signal_state state = {
> { { { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } } }, -1, -1, false, 0, { 0 } };
> return &state;
>}
>
>void boost_asio_signal_handler(int signal_number)
>{
>
>
>
>
>
>
>
> int saved_errno = (*__errno_location ());
> signal_state* state = get_signal_state();
> signed_size_type result = ::write(state->write_descriptor_,
> &signal_number, sizeof(signal_number));
> (void)result;
> (*__errno_location ()) = saved_errno;
>
>
>
>
>
>
>
>}
>
>
>
>
>class signal_set_service::pipe_read_op : public reactor_op
>{
>public:
> pipe_read_op()
> : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
> {
> }
>
> static status do_perform(reactor_op*)
> {
> signal_state* state = get_signal_state();
>
> int fd = state->read_descriptor_;
> int signal_number = 0;
> while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
> if (signal_number >= 0 && signal_number < max_signal_number)
> signal_set_service::deliver_signal(signal_number);
>
> return not_done;
> }
>
> static void do_complete(void* , operation* base,
> const boost::system::error_code& ,
> std::size_t )
> {
> pipe_read_op* o(static_cast<pipe_read_op*>(base));
> delete o;
> }
>};
>
>
>
>
>signal_set_service::signal_set_service(
> boost::asio::io_context& io_context)
> : service_base<signal_set_service>(io_context),
> io_context_(boost::asio::use_service<io_context_impl>(io_context)),
>
>
>
> reactor_(boost::asio::use_service<reactor>(io_context)),
>
>
>
> next_(0),
> prev_(0)
>{
> get_signal_state()->mutex_.init();
>
>
>
>
> reactor_.init_task();
>
>
>
>
> for (int i = 0; i < max_signal_number; ++i)
> registrations_[i] = 0;
>
> add_service(this);
>}
>
>signal_set_service::~signal_set_service()
>{
> remove_service(this);
>}
>
>void signal_set_service::shutdown()
>{
> remove_service(this);
>
> op_queue<operation> ops;
>
> for (int i = 0; i < max_signal_number; ++i)
> {
> registration* reg = registrations_[i];
> while (reg)
> {
> ops.push(*reg->queue_);
> reg = reg->next_in_table_;
> }
> }
>
> io_context_.abandon_operations(ops);
>}
>
>void signal_set_service::notify_fork(
> boost::asio::io_context::fork_event fork_ev)
>{
>
>
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> switch (fork_ev)
> {
> case boost::asio::io_context::fork_prepare:
> {
> int read_descriptor = state->read_descriptor_;
> state->fork_prepared_ = true;
> lock.unlock();
> reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
> reactor_.cleanup_descriptor_data(reactor_data_);
> }
> break;
> case boost::asio::io_context::fork_parent:
> if (state->fork_prepared_)
> {
> int read_descriptor = state->read_descriptor_;
> state->fork_prepared_ = false;
> lock.unlock();
> reactor_.register_internal_descriptor(reactor::read_op,
> read_descriptor, reactor_data_, new pipe_read_op);
> }
> break;
> case boost::asio::io_context::fork_child:
> if (state->fork_prepared_)
> {
> boost::asio::detail::signal_blocker blocker;
> close_descriptors();
> open_descriptors();
> int read_descriptor = state->read_descriptor_;
> state->fork_prepared_ = false;
> lock.unlock();
> reactor_.register_internal_descriptor(reactor::read_op,
> read_descriptor, reactor_data_, new pipe_read_op);
> }
> break;
> default:
> break;
> }
>
>
>
>
>
>
>
>}
>
>void signal_set_service::construct(
> signal_set_service::implementation_type& impl)
>{
> impl.signals_ = 0;
>}
>
>void signal_set_service::destroy(
> signal_set_service::implementation_type& impl)
>{
> boost::system::error_code ignored_ec;
> clear(impl, ignored_ec);
> cancel(impl, ignored_ec);
>}
>
>boost::system::error_code signal_set_service::add(
> signal_set_service::implementation_type& impl,
> int signal_number, boost::system::error_code& ec)
>{
>
> if (signal_number < 0 || signal_number >= max_signal_number)
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
>
> registration** insertion_point = &impl.signals_;
> registration* next = impl.signals_;
> while (next && next->signal_number_ < signal_number)
> {
> insertion_point = &next->next_in_set_;
> next = next->next_in_set_;
> }
>
>
> if (next == 0 || next->signal_number_ != signal_number)
> {
> registration* new_registration = new registration;
>
>
>
> if (state->registration_count_[signal_number] == 0)
> {
>
> using namespace std;
> struct sigaction sa;
> memset(&sa, 0, sizeof(sa));
> sa.__sigaction_handler.sa_handler = boost_asio_signal_handler;
> sigfillset(&sa.sa_mask);
> if (::sigaction(signal_number, &sa, 0) == -1)
>
>
>
> {
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> delete new_registration;
> return ec;
> }
> }
>
>
>
> new_registration->signal_number_ = signal_number;
> new_registration->queue_ = &impl.queue_;
> new_registration->next_in_set_ = next;
> *insertion_point = new_registration;
>
>
> new_registration->next_in_table_ = registrations_[signal_number];
> if (registrations_[signal_number])
> registrations_[signal_number]->prev_in_table_ = new_registration;
> registrations_[signal_number] = new_registration;
>
> ++state->registration_count_[signal_number];
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code signal_set_service::remove(
> signal_set_service::implementation_type& impl,
> int signal_number, boost::system::error_code& ec)
>{
>
> if (signal_number < 0 || signal_number >= max_signal_number)
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
>
> registration** deletion_point = &impl.signals_;
> registration* reg = impl.signals_;
> while (reg && reg->signal_number_ < signal_number)
> {
> deletion_point = &reg->next_in_set_;
> reg = reg->next_in_set_;
> }
>
> if (reg != 0 && reg->signal_number_ == signal_number)
> {
>
>
> if (state->registration_count_[signal_number] == 1)
> {
>
> using namespace std;
> struct sigaction sa;
> memset(&sa, 0, sizeof(sa));
> sa.__sigaction_handler.sa_handler = ((__sighandler_t) 0);
> if (::sigaction(signal_number, &sa, 0) == -1)
>
>
>
> {
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> return ec;
> }
> }
>
>
>
> *deletion_point = reg->next_in_set_;
>
>
> if (registrations_[signal_number] == reg)
> registrations_[signal_number] = reg->next_in_table_;
> if (reg->prev_in_table_)
> reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
> if (reg->next_in_table_)
> reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
>
> --state->registration_count_[signal_number];
>
> delete reg;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code signal_set_service::clear(
> signal_set_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> while (registration* reg = impl.signals_)
> {
>
>
> if (state->registration_count_[reg->signal_number_] == 1)
> {
>
> using namespace std;
> struct sigaction sa;
> memset(&sa, 0, sizeof(sa));
> sa.__sigaction_handler.sa_handler = ((__sighandler_t) 0);
> if (::sigaction(reg->signal_number_, &sa, 0) == -1)
>
>
>
> {
>
>
>
> ec = boost::system::error_code((*__errno_location ()),
> boost::asio::error::get_system_category());
>
> return ec;
> }
> }
>
>
>
> if (registrations_[reg->signal_number_] == reg)
> registrations_[reg->signal_number_] = reg->next_in_table_;
> if (reg->prev_in_table_)
> reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
> if (reg->next_in_table_)
> reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
>
> --state->registration_count_[reg->signal_number_];
>
> impl.signals_ = reg->next_in_set_;
> delete reg;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code signal_set_service::cancel(
> signal_set_service::implementation_type& impl,
> boost::system::error_code& ec)
>{
> (void)0
> ;
>
> op_queue<operation> ops;
> {
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> while (signal_op* op = impl.queue_.front())
> {
> op->ec_ = boost::asio::error::operation_aborted;
> impl.queue_.pop();
> ops.push(op);
> }
> }
>
> io_context_.post_deferred_completions(ops);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void signal_set_service::deliver_signal(int signal_number)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> signal_set_service* service = state->service_list_;
> while (service)
> {
> op_queue<operation> ops;
>
> registration* reg = service->registrations_[signal_number];
> while (reg)
> {
> if (reg->queue_->empty())
> {
> ++reg->undelivered_;
> }
> else
> {
> while (signal_op* op = reg->queue_->front())
> {
> op->signal_number_ = signal_number;
> reg->queue_->pop();
> ops.push(op);
> }
> }
>
> reg = reg->next_in_table_;
> }
>
> service->io_context_.post_deferred_completions(ops);
>
> service = service->next_;
> }
>}
>
>void signal_set_service::add_service(signal_set_service* service)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
>
>
> if (state->service_list_ == 0)
> open_descriptors();
>
>
>
>
> if (state->service_list_ != 0)
> {
> if (!(((static_cast<unsigned>(service->io_context_.concurrency_hint()) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
>
> || !(((static_cast<unsigned>(state->service_list_->io_context_.concurrency_hint()) & (0xFFFF0000u | 0x1u)) ^ 0xA5100000u) != 0)
> )
> {
> std::logic_error ex(
> "Thread-unsafe io_context objects require "
> "exclusive access to signal handling.");
> boost::asio::detail::throw_exception(ex);
> }
> }
>
>
> service->next_ = state->service_list_;
> service->prev_ = 0;
> if (state->service_list_)
> state->service_list_->prev_ = service;
> state->service_list_ = service;
>
>
>
>
>
> int read_descriptor = state->read_descriptor_;
> lock.unlock();
> service->reactor_.register_internal_descriptor(reactor::read_op,
> read_descriptor, service->reactor_data_, new pipe_read_op);
>
>
>
>}
>
>void signal_set_service::remove_service(signal_set_service* service)
>{
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> if (service->next_ || service->prev_ || state->service_list_ == service)
> {
>
>
>
>
> int read_descriptor = state->read_descriptor_;
> lock.unlock();
> service->reactor_.deregister_internal_descriptor(
> read_descriptor, service->reactor_data_);
> service->reactor_.cleanup_descriptor_data(service->reactor_data_);
> lock.lock();
>
>
>
>
>
> if (state->service_list_ == service)
> state->service_list_ = service->next_;
> if (service->prev_)
> service->prev_->next_ = service->next_;
> if (service->next_)
> service->next_->prev_= service->prev_;
> service->next_ = 0;
> service->prev_ = 0;
>
>
>
> if (state->service_list_ == 0)
> close_descriptors();
>
> }
>}
>
>void signal_set_service::open_descriptors()
>{
>
>
>
> signal_state* state = get_signal_state();
>
> int pipe_fds[2];
> if (::pipe(pipe_fds) == 0)
> {
> state->read_descriptor_ = pipe_fds[0];
> ::fcntl(state->read_descriptor_, 4, 04000);
>
> state->write_descriptor_ = pipe_fds[1];
> ::fcntl(state->write_descriptor_, 4, 04000);
>
>
> ::fcntl(state->read_descriptor_, 2, 1);
> ::fcntl(state->write_descriptor_, 2, 1);
>
> }
> else
> {
> boost::system::error_code ec((*__errno_location ()),
> boost::asio::error::get_system_category());
> boost::asio::detail::throw_error(ec, "signal_set_service pipe");
> }
>
>
>
>}
>
>void signal_set_service::close_descriptors()
>{
>
>
>
> signal_state* state = get_signal_state();
>
> if (state->read_descriptor_ != -1)
> ::close(state->read_descriptor_);
> state->read_descriptor_ = -1;
>
> if (state->write_descriptor_ != -1)
> ::close(state->write_descriptor_);
> state->write_descriptor_ = -1;
>
>
>
>}
>
>void signal_set_service::start_wait_op(
> signal_set_service::implementation_type& impl, signal_op* op)
>{
> io_context_.work_started();
>
> signal_state* state = get_signal_state();
> static_mutex::scoped_lock lock(state->mutex_);
>
> registration* reg = impl.signals_;
> while (reg)
> {
> if (reg->undelivered_ > 0)
> {
> --reg->undelivered_;
> op->signal_number_ = reg->signal_number_;
> io_context_.post_deferred_completion(op);
> return;
> }
>
> reg = reg->next_in_set_;
> }
>
> impl.queue_.push(op);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 670 "/usr/include/boost/asio/detail/impl/signal_set_service.ipp" 2 3 4
># 217 "/usr/include/boost/asio/detail/signal_set_service.hpp" 2 3 4
># 31 "/usr/include/boost/asio/signal_set.hpp" 2 3 4
>
>
>namespace boost {
>namespace asio {
># 100 "/usr/include/boost/asio/signal_set.hpp" 3 4
>class signal_set
> : protected basic_io_object<detail::signal_set_service>
>{
>public:
>
> typedef io_context::executor_type executor_type;
># 114 "/usr/include/boost/asio/signal_set.hpp" 3 4
> explicit signal_set(boost::asio::io_context& io_context)
> : basic_io_object<detail::signal_set_service>(io_context)
> {
> }
># 132 "/usr/include/boost/asio/signal_set.hpp" 3 4
> signal_set(boost::asio::io_context& io_context, int signal_number_1)
> : basic_io_object<detail::signal_set_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().add(this->get_implementation(), signal_number_1, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 156 "/usr/include/boost/asio/signal_set.hpp" 3 4
> signal_set(boost::asio::io_context& io_context, int signal_number_1,
> int signal_number_2)
> : basic_io_object<detail::signal_set_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().add(this->get_implementation(), signal_number_1, ec);
> boost::asio::detail::throw_error(ec, "add");
> this->get_service().add(this->get_implementation(), signal_number_2, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 186 "/usr/include/boost/asio/signal_set.hpp" 3 4
> signal_set(boost::asio::io_context& io_context, int signal_number_1,
> int signal_number_2, int signal_number_3)
> : basic_io_object<detail::signal_set_service>(io_context)
> {
> boost::system::error_code ec;
> this->get_service().add(this->get_implementation(), signal_number_1, ec);
> boost::asio::detail::throw_error(ec, "add");
> this->get_service().add(this->get_implementation(), signal_number_2, ec);
> boost::asio::detail::throw_error(ec, "add");
> this->get_service().add(this->get_implementation(), signal_number_3, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
>
>
>
>
>
>
>
> ~signal_set()
> {
> }
># 219 "/usr/include/boost/asio/signal_set.hpp" 3 4
> boost::asio::io_context& get_io_context()
> {
> return basic_io_object<detail::signal_set_service>::get_io_context();
> }
># 233 "/usr/include/boost/asio/signal_set.hpp" 3 4
> boost::asio::io_context& get_io_service()
> {
> return basic_io_object<detail::signal_set_service>::get_io_service();
> }
>
>
>
> executor_type get_executor() noexcept
> {
> return basic_io_object<detail::signal_set_service>::get_executor();
> }
># 254 "/usr/include/boost/asio/signal_set.hpp" 3 4
> void add(int signal_number)
> {
> boost::system::error_code ec;
> this->get_service().add(this->get_implementation(), signal_number, ec);
> boost::asio::detail::throw_error(ec, "add");
> }
># 270 "/usr/include/boost/asio/signal_set.hpp" 3 4
> boost::system::error_code add(int signal_number,
> boost::system::error_code& ec)
> {
> this->get_service().add(this->get_implementation(), signal_number, ec);
> return ec;
> }
># 289 "/usr/include/boost/asio/signal_set.hpp" 3 4
> void remove(int signal_number)
> {
> boost::system::error_code ec;
> this->get_service().remove(this->get_implementation(), signal_number, ec);
> boost::asio::detail::throw_error(ec, "remove");
> }
># 308 "/usr/include/boost/asio/signal_set.hpp" 3 4
> boost::system::error_code remove(int signal_number,
> boost::system::error_code& ec)
> {
> this->get_service().remove(this->get_implementation(), signal_number, ec);
> return ec;
> }
># 324 "/usr/include/boost/asio/signal_set.hpp" 3 4
> void clear()
> {
> boost::system::error_code ec;
> this->get_service().clear(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "clear");
> }
># 340 "/usr/include/boost/asio/signal_set.hpp" 3 4
> boost::system::error_code clear(boost::system::error_code& ec)
> {
> this->get_service().clear(this->get_implementation(), ec);
> return ec;
> }
># 367 "/usr/include/boost/asio/signal_set.hpp" 3 4
> void cancel()
> {
> boost::system::error_code ec;
> this->get_service().cancel(this->get_implementation(), ec);
> boost::asio::detail::throw_error(ec, "cancel");
> }
># 395 "/usr/include/boost/asio/signal_set.hpp" 3 4
> boost::system::error_code cancel(boost::system::error_code& ec)
> {
> this->get_service().cancel(this->get_implementation(), ec);
> return ec;
> }
># 426 "/usr/include/boost/asio/signal_set.hpp" 3 4
> template <typename SignalHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<SignalHandler>::type, void (boost::system::error_code, int)>::return_type
>
> async_wait(SignalHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<SignalHandler>::type, void(boost::system::error_code, int)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const int*>(0))) == 1, "SignalHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const int>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<SignalHandler,
> void (boost::system::error_code, int)> init(handler);
>
> this->get_service().async_wait(this->get_implementation(),
> init.completion_handler);
>
> return init.result.get();
> }
>};
>
>
>}
>}
># 119 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/signal_set_service.hpp" 1 3 4
># 120 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/socket_acceptor_service.hpp" 1 3 4
># 121 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/steady_timer.hpp" 1 3 4
># 25 "/usr/include/boost/asio/steady_timer.hpp" 3 4
>namespace boost {
>namespace asio {
># 37 "/usr/include/boost/asio/steady_timer.hpp" 3 4
>typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
>
>}
>}
># 123 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/strand.hpp" 1 3 4
># 19 "/usr/include/boost/asio/strand.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 1 3 4
># 28 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>class strand_executor_service
> : public execution_context_service_base<strand_executor_service>
>{
>public:
>
> class strand_impl
> {
> public:
> inline ~strand_impl();
>
> private:
> friend class strand_executor_service;
>
>
> mutex* mutex_;
>
>
>
>
> bool locked_;
>
>
>
>
> op_queue<scheduler_operation> waiting_queue_;
>
>
>
>
> op_queue<scheduler_operation> ready_queue_;
>
>
> strand_impl* next_;
> strand_impl* prev_;
>
>
> strand_executor_service* service_;
> };
>
> typedef shared_ptr<strand_impl> implementation_type;
>
>
> inline explicit strand_executor_service(execution_context& context);
>
>
> inline void shutdown();
>
>
> inline implementation_type create_implementation();
>
>
> template <typename Executor, typename Function, typename Allocator>
> static void dispatch(const implementation_type& impl, Executor& ex,
> Function&& function, const Allocator& a);
>
>
> template <typename Executor, typename Function, typename Allocator>
> static void post(const implementation_type& impl, Executor& ex,
> Function&& function, const Allocator& a);
>
>
> template <typename Executor, typename Function, typename Allocator>
> static void defer(const implementation_type& impl, Executor& ex,
> Function&& function, const Allocator& a);
>
>
> inline static bool running_in_this_thread(
> const implementation_type& impl);
>
>private:
> friend class strand_impl;
> template <typename Executor> class invoker;
>
>
> inline static bool enqueue(const implementation_type& impl,
> scheduler_operation* op);
>
>
> mutex mutex_;
>
>
> enum { num_mutexes = 193 };
>
>
> scoped_ptr<mutex> mutexes_[num_mutexes];
>
>
>
> std::size_t salt_;
>
>
> strand_impl* impl_list_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 134 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/strand_executor_service.hpp" 1 3 4
># 24 "/usr/include/boost/asio/detail/impl/strand_executor_service.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/detail/impl/strand_executor_service.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Executor>
>class strand_executor_service::invoker
>{
>public:
> invoker(const implementation_type& impl, Executor& ex)
> : impl_(impl),
> work_(ex)
> {
> }
>
> invoker(const invoker& other)
> : impl_(other.impl_),
> work_(other.work_)
> {
> }
>
>
> invoker(invoker&& other)
> : impl_(static_cast<implementation_type&&>(other.impl_)),
> work_(static_cast<executor_work_guard<Executor>&&>(other.work_))
> {
> }
>
>
> struct on_invoker_exit
> {
> invoker* this_;
>
> ~on_invoker_exit()
> {
> this_->impl_->mutex_->lock();
> this_->impl_->ready_queue_.push(this_->impl_->waiting_queue_);
> bool more_handlers = this_->impl_->locked_ =
> !this_->impl_->ready_queue_.empty();
> this_->impl_->mutex_->unlock();
>
> if (more_handlers)
> {
> Executor ex(this_->work_.get_executor());
> recycling_allocator<void> allocator;
> ex.post(static_cast<invoker&&>(*this_), allocator);
> }
> }
> };
>
> void operator()()
> {
>
> call_stack<strand_impl>::context ctx(impl_.get());
>
>
> on_invoker_exit on_exit = { this };
> (void)on_exit;
>
>
>
> boost::system::error_code ec;
> while (scheduler_operation* o = impl_->ready_queue_.front())
> {
> impl_->ready_queue_.pop();
> o->complete(impl_.get(), ec, 0);
> }
> }
>
>private:
> implementation_type impl_;
> executor_work_guard<Executor> work_;
>};
>
>template <typename Executor, typename Function, typename Allocator>
>void strand_executor_service::dispatch(const implementation_type& impl,
> Executor& ex, Function&& function, const Allocator& a)
>{
> typedef typename decay<Function>::type function_type;
>
>
> if (call_stack<strand_impl>::contains(impl.get()))
> {
>
> function_type tmp(static_cast<Function&&>(function));
>
> fenced_block b(fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
> return;
> }
>
>
> typedef executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(function), a);
>
> (void)0
> ;
>
>
> bool first = enqueue(impl, p.p);
> p.v = p.p = 0;
> if (first)
> ex.dispatch(invoker<Executor>(impl, ex), a);
>}
>
>
>template <typename Executor, typename Function, typename Allocator>
>void strand_executor_service::post(const implementation_type& impl,
> Executor& ex, Function&& function, const Allocator& a)
>{
> typedef typename decay<Function>::type function_type;
>
>
> typedef executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(function), a);
>
> (void)0
> ;
>
>
> bool first = enqueue(impl, p.p);
> p.v = p.p = 0;
> if (first)
> ex.post(invoker<Executor>(impl, ex), a);
>}
>
>
>template <typename Executor, typename Function, typename Allocator>
>void strand_executor_service::defer(const implementation_type& impl,
> Executor& ex, Function&& function, const Allocator& a)
>{
> typedef typename decay<Function>::type function_type;
>
>
> typedef executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(function), a);
>
> (void)0
> ;
>
>
> bool first = enqueue(impl, p.p);
> p.v = p.p = 0;
> if (first)
> ex.defer(invoker<Executor>(impl, ex), a);
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 180 "/usr/include/boost/asio/detail/impl/strand_executor_service.hpp" 2 3 4
># 136 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/impl/strand_executor_service.ipp" 1 3 4
># 19 "/usr/include/boost/asio/detail/impl/strand_executor_service.ipp" 3 4
># 1 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 1 3 4
># 20 "/usr/include/boost/asio/detail/impl/strand_executor_service.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/detail/impl/strand_executor_service.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>strand_executor_service::strand_executor_service(execution_context& ctx)
> : execution_context_service_base<strand_executor_service>(ctx),
> mutex_(),
> salt_(0),
> impl_list_(0)
>{
>}
>
>void strand_executor_service::shutdown()
>{
> op_queue<scheduler_operation> ops;
>
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
> strand_impl* impl = impl_list_;
> while (impl)
> {
> ops.push(impl->waiting_queue_);
> ops.push(impl->ready_queue_);
> impl = impl->next_;
> }
>}
>
>strand_executor_service::implementation_type
>strand_executor_service::create_implementation()
>{
> implementation_type new_impl(new strand_impl);
> new_impl->locked_ = false;
>
> boost::asio::detail::mutex::scoped_lock lock(mutex_);
>
>
> std::size_t salt = salt_++;
> std::size_t mutex_index = reinterpret_cast<std::size_t>(new_impl.get());
> mutex_index += (reinterpret_cast<std::size_t>(new_impl.get()) >> 3);
> mutex_index ^= salt + 0x9e3779b9 + (mutex_index << 6) + (mutex_index >> 2);
> mutex_index = mutex_index % num_mutexes;
> if (!mutexes_[mutex_index].get())
> mutexes_[mutex_index].reset(new mutex);
> new_impl->mutex_ = mutexes_[mutex_index].get();
>
>
> new_impl->next_ = impl_list_;
> new_impl->prev_ = 0;
> if (impl_list_)
> impl_list_->prev_ = new_impl.get();
> impl_list_ = new_impl.get();
> new_impl->service_ = this;
>
> return new_impl;
>}
>
>strand_executor_service::strand_impl::~strand_impl()
>{
> boost::asio::detail::mutex::scoped_lock lock(service_->mutex_);
>
>
> if (service_->impl_list_ == this)
> service_->impl_list_ = next_;
> if (prev_)
> prev_->next_ = next_;
> if (next_)
> next_->prev_= prev_;
>}
>
>bool strand_executor_service::enqueue(const implementation_type& impl,
> scheduler_operation* op)
>{
> impl->mutex_->lock();
> if (impl->locked_)
> {
>
> impl->waiting_queue_.push(op);
> impl->mutex_->unlock();
> return false;
> }
> else
> {
>
>
> impl->locked_ = true;
> impl->mutex_->unlock();
> impl->ready_queue_.push(op);
> return true;
> }
>}
>
>bool strand_executor_service::running_in_this_thread(
> const implementation_type& impl)
>{
> return !!call_stack<strand_impl>::contains(impl.get());
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 125 "/usr/include/boost/asio/detail/impl/strand_executor_service.ipp" 2 3 4
># 138 "/usr/include/boost/asio/detail/strand_executor_service.hpp" 2 3 4
># 20 "/usr/include/boost/asio/strand.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/strand.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>
>template <typename Executor>
>class strand
>{
>public:
>
> typedef Executor inner_executor_type;
>
>
>
>
>
>
> strand()
> : executor_(),
> impl_(use_service<detail::strand_executor_service>(
> executor_.context()).create_implementation())
> {
> }
>
>
> explicit strand(const Executor& e)
> : executor_(e),
> impl_(use_service<detail::strand_executor_service>(
> executor_.context()).create_implementation())
> {
> }
>
>
> strand(const strand& other) noexcept
> : executor_(other.executor_),
> impl_(other.impl_)
> {
> }
>
>
>
>
>
>
> template <class OtherExecutor>
> strand(
> const strand<OtherExecutor>& other) noexcept
> : executor_(other.executor_),
> impl_(other.impl_)
> {
> }
>
>
> strand& operator=(const strand& other) noexcept
> {
> executor_ = other.executor_;
> impl_ = other.impl_;
> return *this;
> }
>
>
>
>
>
>
> template <class OtherExecutor>
> strand& operator=(
> const strand<OtherExecutor>& other) noexcept
> {
> executor_ = other.executor_;
> impl_ = other.impl_;
> return *this;
> }
>
>
>
> strand(strand&& other) noexcept
> : executor_(static_cast<Executor&&>(other.executor_)),
> impl_(static_cast<implementation_type&&>(other.impl_))
> {
> }
>
>
>
>
>
>
> template <class OtherExecutor>
> strand(strand<OtherExecutor>&& other) noexcept
> : executor_(static_cast<OtherExecutor&&>(other)),
> impl_(static_cast<implementation_type&&>(other.impl_))
> {
> }
>
>
> strand& operator=(strand&& other) noexcept
> {
> executor_ = static_cast<Executor&&>(other);
> impl_ = static_cast<implementation_type&&>(other.impl_);
> return *this;
> }
>
>
>
>
>
>
> template <class OtherExecutor>
> strand& operator=(
> const strand<OtherExecutor>&& other) noexcept
> {
> executor_ = static_cast<OtherExecutor&&>(other);
> impl_ = static_cast<implementation_type&&>(other.impl_);
> return *this;
> }
>
>
>
> ~strand()
> {
> }
>
>
> inner_executor_type get_inner_executor() const noexcept
> {
> return executor_;
> }
>
>
> execution_context& context() const noexcept
> {
> return executor_.context();
> }
>
>
>
>
>
> void on_work_started() const noexcept
> {
> executor_.on_work_started();
> }
>
>
>
>
>
> void on_work_finished() const noexcept
> {
> executor_.on_work_finished();
> }
># 190 "/usr/include/boost/asio/strand.hpp" 3 4
> template <typename Function, typename Allocator>
> void dispatch(Function&& f, const Allocator& a) const
> {
> detail::strand_executor_service::dispatch(impl_,
> executor_, static_cast<Function&&>(f), a);
> }
># 210 "/usr/include/boost/asio/strand.hpp" 3 4
> template <typename Function, typename Allocator>
> void post(Function&& f, const Allocator& a) const
> {
> detail::strand_executor_service::post(impl_,
> executor_, static_cast<Function&&>(f), a);
> }
># 230 "/usr/include/boost/asio/strand.hpp" 3 4
> template <typename Function, typename Allocator>
> void defer(Function&& f, const Allocator& a) const
> {
> detail::strand_executor_service::defer(impl_,
> executor_, static_cast<Function&&>(f), a);
> }
>
>
>
>
>
>
>
> bool running_in_this_thread() const noexcept
> {
> return detail::strand_executor_service::running_in_this_thread(impl_);
> }
>
>
>
>
>
>
> friend bool operator==(const strand& a, const strand& b) noexcept
> {
> return a.impl_ == b.impl_;
> }
>
>
>
>
>
>
> friend bool operator!=(const strand& a, const strand& b) noexcept
> {
> return a.impl_ != b.impl_;
> }
>
>private:
> Executor executor_;
> typedef detail::strand_executor_service::implementation_type
> implementation_type;
> implementation_type impl_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 279 "/usr/include/boost/asio/strand.hpp" 2 3 4
># 124 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/stream_socket_service.hpp" 1 3 4
># 125 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/streambuf.hpp" 1 3 4
># 24 "/usr/include/boost/asio/streambuf.hpp" 3 4
>namespace boost {
>namespace asio {
>
>
>typedef basic_streambuf<> streambuf;
>
>}
>}
># 126 "/usr/include/boost/asio.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/system_timer.hpp" 1 3 4
># 25 "/usr/include/boost/asio/system_timer.hpp" 3 4
>namespace boost {
>namespace asio {
># 37 "/usr/include/boost/asio/system_timer.hpp" 3 4
>typedef basic_waitable_timer<chrono::system_clock> system_timer;
>
>}
>}
># 129 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/thread_pool.hpp" 1 3 4
># 24 "/usr/include/boost/asio/thread_pool.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/thread_pool.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 64 "/usr/include/boost/asio/thread_pool.hpp" 3 4
>class thread_pool
> : public execution_context
>{
>public:
> class executor_type;
>
>
> inline thread_pool();
>
>
> inline thread_pool(std::size_t num_threads);
>
>
>
>
>
> inline ~thread_pool();
>
>
> executor_type get_executor() noexcept;
>
>
>
>
>
>
> inline void stop();
>
>
>
>
>
>
>
> inline void join();
>
>private:
> friend class executor_type;
> struct thread_function;
>
>
> detail::scheduler& scheduler_;
>
>
> detail::thread_group threads_;
>};
>
>
>class thread_pool::executor_type
>{
>public:
>
> thread_pool& context() const noexcept;
>
>
>
>
>
>
>
> void on_work_started() const noexcept;
>
>
>
>
>
>
>
> void on_work_finished() const noexcept;
># 148 "/usr/include/boost/asio/thread_pool.hpp" 3 4
> template <typename Function, typename Allocator>
> void dispatch(Function&& f, const Allocator& a) const;
># 164 "/usr/include/boost/asio/thread_pool.hpp" 3 4
> template <typename Function, typename Allocator>
> void post(Function&& f, const Allocator& a) const;
># 184 "/usr/include/boost/asio/thread_pool.hpp" 3 4
> template <typename Function, typename Allocator>
> void defer(Function&& f, const Allocator& a) const;
>
>
>
>
>
>
> bool running_in_this_thread() const noexcept;
>
>
>
>
>
> friend bool operator==(const executor_type& a,
> const executor_type& b) noexcept
> {
> return &a.pool_ == &b.pool_;
> }
>
>
>
>
>
> friend bool operator!=(const executor_type& a,
> const executor_type& b) noexcept
> {
> return &a.pool_ != &b.pool_;
> }
>
>private:
> friend class thread_pool;
>
>
> explicit executor_type(thread_pool& p) : pool_(p) {}
>
>
> thread_pool& pool_;
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 228 "/usr/include/boost/asio/thread_pool.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/thread_pool.hpp" 1 3 4
># 24 "/usr/include/boost/asio/impl/thread_pool.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/impl/thread_pool.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>inline thread_pool::executor_type
>thread_pool::get_executor() noexcept
>{
> return executor_type(*this);
>}
>
>inline thread_pool&
>thread_pool::executor_type::context() const noexcept
>{
> return pool_;
>}
>
>inline void
>thread_pool::executor_type::on_work_started() const noexcept
>{
> pool_.scheduler_.work_started();
>}
>
>inline void thread_pool::executor_type::on_work_finished()
>const noexcept
>{
> pool_.scheduler_.work_finished();
>}
>
>template <typename Function, typename Allocator>
>void thread_pool::executor_type::dispatch(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
>
> if (pool_.scheduler_.can_dispatch())
> {
>
> function_type tmp(static_cast<Function&&>(f));
>
> detail::fenced_block b(detail::fenced_block::full);
> boost_asio_handler_invoke_helpers::invoke(tmp, tmp);
> return;
> }
>
>
> typedef detail::executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> pool_.scheduler_.post_immediate_completion(p.p, false);
> p.v = p.p = 0;
>}
>
>template <typename Function, typename Allocator>
>void thread_pool::executor_type::post(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
>
> typedef detail::executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> pool_.scheduler_.post_immediate_completion(p.p, false);
> p.v = p.p = 0;
>}
>
>template <typename Function, typename Allocator>
>void thread_pool::executor_type::defer(
> Function&& f, const Allocator& a) const
>{
> typedef typename decay<Function>::type function_type;
>
>
> typedef detail::executor_op<function_type, Allocator> op;
> typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
> p.p = new (p.v) op(static_cast<Function&&>(f), a);
>
> (void)0
> ;
>
> pool_.scheduler_.post_immediate_completion(p.p, true);
> p.v = p.p = 0;
>}
>
>inline bool
>thread_pool::executor_type::running_in_this_thread() const noexcept
>{
> return pool_.scheduler_.can_dispatch();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 128 "/usr/include/boost/asio/impl/thread_pool.hpp" 2 3 4
># 230 "/usr/include/boost/asio/thread_pool.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/thread_pool.ipp" 1 3 4
># 19 "/usr/include/boost/asio/impl/thread_pool.ipp" 3 4
># 1 "/usr/include/boost/asio/thread_pool.hpp" 1 3 4
># 20 "/usr/include/boost/asio/impl/thread_pool.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/impl/thread_pool.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>struct thread_pool::thread_function
>{
> detail::scheduler* scheduler_;
>
> void operator()()
> {
> boost::system::error_code ec;
> scheduler_->run(ec);
> }
>};
>
>thread_pool::thread_pool()
> : scheduler_(use_service<detail::scheduler>(*this))
>{
> scheduler_.work_started();
>
> thread_function f = { &scheduler_ };
> std::size_t num_threads = detail::thread::hardware_concurrency() * 2;
> threads_.create_threads(f, num_threads ? num_threads : 2);
>}
>
>thread_pool::thread_pool(std::size_t num_threads)
> : scheduler_(use_service<detail::scheduler>(*this))
>{
> scheduler_.work_started();
>
> thread_function f = { &scheduler_ };
> threads_.create_threads(f, num_threads);
>}
>
>thread_pool::~thread_pool()
>{
> stop();
> join();
>}
>
>void thread_pool::stop()
>{
> scheduler_.stop();
>}
>
>void thread_pool::join()
>{
> scheduler_.work_finished();
> threads_.join();
>}
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 77 "/usr/include/boost/asio/impl/thread_pool.ipp" 2 3 4
># 232 "/usr/include/boost/asio/thread_pool.hpp" 2 3 4
># 130 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/use_future.hpp" 1 3 4
># 26 "/usr/include/boost/asio/use_future.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/use_future.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>template <typename Function, typename Allocator>
>class packaged_token;
>
>template <typename Function, typename Allocator, typename Result>
>class packaged_handler;
>
>}
># 55 "/usr/include/boost/asio/use_future.hpp" 3 4
>template <typename Allocator = std::allocator<void> >
>class use_future_t
>{
>public:
>
>
> typedef Allocator allocator_type;
>
>
> constexpr use_future_t()
> {
> }
>
>
> explicit use_future_t(const Allocator& allocator)
> : allocator_(allocator)
> {
> }
>
>
>
> template <typename OtherAllocator>
> use_future_t<OtherAllocator> operator[](const OtherAllocator& allocator) const
> {
> return use_future_t<OtherAllocator>(allocator);
> }
>
>
>
> template <typename OtherAllocator>
> use_future_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
> {
> return use_future_t<OtherAllocator>(allocator);
> }
>
>
> allocator_type get_allocator() const
> {
> return allocator_;
> }
># 113 "/usr/include/boost/asio/use_future.hpp" 3 4
> template <typename Function>
>
>
>
> detail::packaged_token<typename decay<Function>::type, Allocator>
>
> operator()(Function&& f) const;
>
>private:
>
>
> struct std_allocator_void
> {
> constexpr std_allocator_void()
> {
> }
>
> operator std::allocator<void>() const
> {
> return std::allocator<void>();
> }
> };
>
> typename conditional<
> is_same<std::allocator<void>, Allocator>::value,
> std_allocator_void, Allocator>::type allocator_;
>};
>
>
>
>
>
>
>constexpr use_future_t<> use_future;
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 155 "/usr/include/boost/asio/use_future.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/use_future.hpp" 1 3 4
># 28 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/impl/use_future.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace detail {
>
>
>
>template <typename T, typename F, typename... Args>
>inline void promise_invoke_and_set(std::promise<T>& p,
> F& f, Args&&... args)
>{
>
> try
>
> {
> p.set_value(f(static_cast<Args&&>(args)...));
> }
>
> catch (...)
> {
> p.set_exception(std::current_exception());
> }
>
>}
>
>template <typename F, typename... Args>
>inline void promise_invoke_and_set(std::promise<void>& p,
> F& f, Args&&... args)
>{
>
> try
>
> {
> f(static_cast<Args&&>(args)...);
> p.set_value();
> }
>
> catch (...)
> {
> p.set_exception(std::current_exception());
> }
>
>}
># 172 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>template <typename T, typename F>
>class promise_invoker
>{
>public:
> promise_invoker(const shared_ptr<std::promise<T> >& p,
> F&& f)
> : p_(p), f_(static_cast<F&&>(f))
> {
> }
>
> void operator()()
> {
>
> try
>
> {
> f_();
> }
>
> catch (...)
> {
> p_->set_exception(std::current_exception());
> }
>
> }
>
>private:
> shared_ptr<std::promise<T> > p_;
> typename decay<F>::type f_;
>};
>
>
>
>template <typename T>
>class promise_executor
>{
>public:
> explicit promise_executor(const shared_ptr<std::promise<T> >& p)
> : p_(p)
> {
> }
>
> execution_context& context() const noexcept
> {
> return system_executor().context();
> }
>
> void on_work_started() const noexcept {}
> void on_work_finished() const noexcept {}
>
> template <typename F, typename A>
> void dispatch(F&& f, const A&) const
> {
> promise_invoker<T, F>(p_, static_cast<F&&>(f))();
> }
>
> template <typename F, typename A>
> void post(F&& f, const A& a) const
> {
> system_executor().post(
> promise_invoker<T, F>(p_, static_cast<F&&>(f)), a);
> }
>
> template <typename F, typename A>
> void defer(F&& f, const A& a) const
> {
> system_executor().defer(
> promise_invoker<T, F>(p_, static_cast<F&&>(f)), a);
> }
>
> friend bool operator==(const promise_executor& a,
> const promise_executor& b) noexcept
> {
> return a.p_ == b.p_;
> }
>
> friend bool operator!=(const promise_executor& a,
> const promise_executor& b) noexcept
> {
> return a.p_ != b.p_;
> }
>
>private:
> shared_ptr<std::promise<T> > p_;
>};
>
>
>template <typename T>
>class promise_creator
>{
>public:
> typedef promise_executor<T> executor_type;
>
> executor_type get_executor() const noexcept
> {
> return executor_type(p_);
> }
>
> typedef std::future<T> future_type;
>
> future_type get_future()
> {
> return p_->get_future();
> }
>
>protected:
> template <typename Allocator>
> void create_promise(const Allocator& a)
> {
> typename std::allocator_traits<Allocator>::template rebind_alloc<char> b(a);
> p_ = std::allocate_shared<std::promise<T>>(b, std::allocator_arg, b);
> }
>
> shared_ptr<std::promise<T> > p_;
>};
>
>
>class promise_handler_0
> : public promise_creator<void>
>{
>public:
> void operator()()
> {
> this->p_->set_value();
> }
>};
>
>
>class promise_handler_ec_0
> : public promise_creator<void>
>{
>public:
> void operator()(const boost::system::error_code& ec)
> {
> if (ec)
> {
> this->p_->set_exception(
> std::make_exception_ptr(
> boost::system::system_error(ec)));
> }
> else
> {
> this->p_->set_value();
> }
> }
>};
>
>
>class promise_handler_ex_0
> : public promise_creator<void>
>{
>public:
> void operator()(const std::exception_ptr& ex)
> {
> if (ex)
> {
> this->p_->set_exception(ex);
> }
> else
> {
> this->p_->set_value();
> }
> }
>};
>
>
>template <typename T>
>class promise_handler_1
> : public promise_creator<T>
>{
>public:
> template <typename Arg>
> void operator()(Arg&& arg)
> {
> this->p_->set_value(static_cast<Arg&&>(arg));
> }
>};
>
>
>template <typename T>
>class promise_handler_ec_1
> : public promise_creator<T>
>{
>public:
> template <typename Arg>
> void operator()(const boost::system::error_code& ec,
> Arg&& arg)
> {
> if (ec)
> {
> this->p_->set_exception(
> std::make_exception_ptr(
> boost::system::system_error(ec)));
> }
> else
> this->p_->set_value(static_cast<Arg&&>(arg));
> }
>};
>
>
>template <typename T>
>class promise_handler_ex_1
> : public promise_creator<T>
>{
>public:
> template <typename Arg>
> void operator()(const std::exception_ptr& ex,
> Arg&& arg)
> {
> if (ex)
> this->p_->set_exception(ex);
> else
> this->p_->set_value(static_cast<Arg&&>(arg));
> }
>};
>
>
>template <typename T>
>class promise_handler_n
> : public promise_creator<T>
>{
>public:
>
>
> template <typename... Args>
> void operator()(Args&&... args)
> {
> this->p_->set_value(
> std::forward_as_tuple(
> static_cast<Args&&>(args)...));
> }
># 419 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>};
>
>
>template <typename T>
>class promise_handler_ec_n
> : public promise_creator<T>
>{
>public:
>
>
> template <typename... Args>
> void operator()(const boost::system::error_code& ec,
> Args&&... args)
> {
> if (ec)
> {
> this->p_->set_exception(
> std::make_exception_ptr(
> boost::system::system_error(ec)));
> }
> else
> {
> this->p_->set_value(
> std::forward_as_tuple(
> static_cast<Args&&>(args)...));
> }
> }
># 472 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>};
>
>
>template <typename T>
>class promise_handler_ex_n
> : public promise_creator<T>
>{
>public:
>
>
> template <typename... Args>
> void operator()(const std::exception_ptr& ex,
> Args&&... args)
> {
> if (ex)
> this->p_->set_exception(ex);
> else
> {
> this->p_->set_value(
> std::forward_as_tuple(
> static_cast<Args&&>(args)...));
> }
> }
># 517 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>};
>
>
>
>template <typename> class promise_handler_selector;
>
>template <>
>class promise_handler_selector<void()>
> : public promise_handler_0 {};
>
>template <>
>class promise_handler_selector<void(boost::system::error_code)>
> : public promise_handler_ec_0 {};
>
>template <>
>class promise_handler_selector<void(std::exception_ptr)>
> : public promise_handler_ex_0 {};
>
>template <typename Arg>
>class promise_handler_selector<void(Arg)>
> : public promise_handler_1<Arg> {};
>
>template <typename Arg>
>class promise_handler_selector<void(boost::system::error_code, Arg)>
> : public promise_handler_ec_1<Arg> {};
>
>template <typename Arg>
>class promise_handler_selector<void(std::exception_ptr, Arg)>
> : public promise_handler_ex_1<Arg> {};
>
>
>
>template <typename... Arg>
>class promise_handler_selector<void(Arg...)>
> : public promise_handler_n<std::tuple<Arg...> > {};
>
>template <typename... Arg>
>class promise_handler_selector<void(boost::system::error_code, Arg...)>
> : public promise_handler_ec_n<std::tuple<Arg...> > {};
>
>template <typename... Arg>
>class promise_handler_selector<void(std::exception_ptr, Arg...)>
> : public promise_handler_ex_n<std::tuple<Arg...> > {};
># 589 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>template <typename Signature, typename Allocator>
>class promise_handler
> : public promise_handler_selector<Signature>
>{
>public:
> typedef Allocator allocator_type;
> typedef void result_type;
>
> promise_handler(use_future_t<Allocator> u)
> : allocator_(u.get_allocator())
> {
> this->create_promise(allocator_);
> }
>
> allocator_type get_allocator() const noexcept
> {
> return allocator_;
> }
>
>private:
> Allocator allocator_;
>};
>
>template <typename Function, typename Signature, typename Allocator>
>inline void asio_handler_invoke(Function& f,
> promise_handler<Signature, Allocator>* h)
>{
> typename promise_handler<Signature, Allocator>::executor_type
> ex(h->get_executor());
> ex.dispatch(static_cast<Function&&>(f), std::allocator<void>());
>}
>
>template <typename Function, typename Signature, typename Allocator>
>inline void asio_handler_invoke(const Function& f,
> promise_handler<Signature, Allocator>* h)
>{
> typename promise_handler<Signature, Allocator>::executor_type
> ex(h->get_executor());
> ex.dispatch(f, std::allocator<void>());
>}
>
>
>template <typename Signature, typename Allocator>
>class promise_async_result
>{
>public:
> typedef promise_handler<Signature, Allocator> completion_handler_type;
> typedef typename completion_handler_type::future_type return_type;
>
> explicit promise_async_result(completion_handler_type& h)
> : future_(h.get_future())
> {
> }
>
> return_type get()
> {
> return static_cast<return_type&&>(future_);
> }
>
>private:
> return_type future_;
>};
>
>
>template <typename Function, typename Allocator>
>class packaged_token
>{
>public:
> packaged_token(Function f, const Allocator& a)
> : function_(static_cast<Function&&>(f)),
> allocator_(a)
> {
> }
>
>
> Function function_;
> Allocator allocator_;
>};
>
>
>
>template <typename Function, typename Allocator, typename Result>
>class packaged_handler
> : public promise_creator<Result>
>{
>public:
> typedef Allocator allocator_type;
> typedef void result_type;
>
> packaged_handler(packaged_token<Function, Allocator> t)
> : function_(static_cast<Function&&>(t.function_)),
> allocator_(t.allocator_)
> {
> this->create_promise(allocator_);
> }
>
> allocator_type get_allocator() const noexcept
> {
> return allocator_;
> }
>
>
>
> template <typename... Args>
> void operator()(Args&&... args)
> {
> (promise_invoke_and_set)(*this->p_,
> function_, static_cast<Args&&>(args)...);
> }
># 719 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>private:
> Function function_;
> Allocator allocator_;
>};
>
>template <typename Function,
> typename Function1, typename Allocator, typename Result>
>inline void asio_handler_invoke(Function& f,
> packaged_handler<Function1, Allocator, Result>* h)
>{
> typename packaged_handler<Function1, Allocator, Result>::executor_type
> ex(h->get_executor());
> ex.dispatch(static_cast<Function&&>(f), std::allocator<void>());
>}
>
>template <typename Function,
> typename Function1, typename Allocator, typename Result>
>inline void asio_handler_invoke(const Function& f,
> packaged_handler<Function1, Allocator, Result>* h)
>{
> typename packaged_handler<Function1, Allocator, Result>::executor_type
> ex(h->get_executor());
> ex.dispatch(f, std::allocator<void>());
>}
>
>
>template <typename Function, typename Allocator, typename Result>
>class packaged_async_result
>{
>public:
> typedef packaged_handler<Function, Allocator, Result> completion_handler_type;
> typedef typename completion_handler_type::future_type return_type;
>
> explicit packaged_async_result(completion_handler_type& h)
> : future_(h.get_future())
> {
> }
>
> return_type get()
> {
> return static_cast<return_type&&>(future_);
> }
>
>private:
> return_type future_;
>};
>
>}
>
>template <typename Allocator> template <typename Function>
>inline detail::packaged_token<typename decay<Function>::type, Allocator>
>use_future_t<Allocator>::operator()(Function&& f) const
>{
> return detail::packaged_token<typename decay<Function>::type, Allocator>(
> static_cast<Function&&>(f), allocator_);
>}
>
>
>
>
>
>template <typename Allocator, typename Result, typename... Args>
>class async_result<use_future_t<Allocator>, Result(Args...)>
> : public detail::promise_async_result<
> void(typename decay<Args>::type...), Allocator>
>{
>public:
> explicit async_result(
> typename detail::promise_async_result<void(typename decay<Args>::type...),
> Allocator>::completion_handler_type& h)
> : detail::promise_async_result<
> void(typename decay<Args>::type...), Allocator>(h)
> {
> }
>};
>
>template <typename Function, typename Allocator,
> typename Result, typename... Args>
>class async_result<detail::packaged_token<Function, Allocator>, Result(Args...)>
> : public detail::packaged_async_result<Function, Allocator,
> typename result_of<Function(Args...)>::type>
>{
>public:
> explicit async_result(
> typename detail::packaged_async_result<Function, Allocator,
> typename result_of<Function(Args...)>::type>::completion_handler_type& h)
> : detail::packaged_async_result<Function, Allocator,
> typename result_of<Function(Args...)>::type>(h)
> {
> }
>};
># 885 "/usr/include/boost/asio/impl/use_future.hpp" 3 4
>template <typename Allocator, typename Signature>
>struct handler_type<use_future_t<Allocator>, Signature>
>{
> typedef typename async_result<use_future_t<Allocator>,
> Signature>::completion_handler_type type;
>};
>
>template <typename Signature, typename Allocator>
>class async_result<detail::promise_handler<Signature, Allocator> >
> : public detail::promise_async_result<Signature, Allocator>
>{
>public:
> typedef typename detail::promise_async_result<
> Signature, Allocator>::return_type type;
>
> explicit async_result(
> typename detail::promise_async_result<
> Signature, Allocator>::completion_handler_type& h)
> : detail::promise_async_result<Signature, Allocator>(h)
> {
> }
>};
>
>template <typename Function, typename Allocator, typename Signature>
>struct handler_type<detail::packaged_token<Function, Allocator>, Signature>
>{
> typedef typename async_result<detail::packaged_token<Function, Allocator>,
> Signature>::completion_handler_type type;
>};
>
>template <typename Function, typename Allocator, typename Result>
>class async_result<detail::packaged_handler<Function, Allocator, Result> >
> : public detail::packaged_async_result<Function, Allocator, Result>
>{
>public:
> typedef typename detail::packaged_async_result<
> Function, Allocator, Result>::return_type type;
>
> explicit async_result(
> typename detail::packaged_async_result<
> Function, Allocator, Result>::completion_handler_type& h)
> : detail::packaged_async_result<Function, Allocator, Result>(h)
> {
> }
>};
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 939 "/usr/include/boost/asio/impl/use_future.hpp" 2 3 4
># 157 "/usr/include/boost/asio/use_future.hpp" 2 3 4
># 132 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/version.hpp" 1 3 4
># 134 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/waitable_timer_service.hpp" 1 3 4
># 136 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_handle.hpp" 1 3 4
># 137 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_object_handle.hpp" 1 3 4
># 138 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_random_access_handle.hpp" 1 3 4
># 139 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/basic_stream_handle.hpp" 1 3 4
># 140 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/object_handle.hpp" 1 3 4
># 141 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/object_handle_service.hpp" 1 3 4
># 142 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/overlapped_handle.hpp" 1 3 4
># 143 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/overlapped_ptr.hpp" 1 3 4
># 144 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/random_access_handle.hpp" 1 3 4
># 145 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/random_access_handle_service.hpp" 1 3 4
># 146 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/stream_handle.hpp" 1 3 4
># 147 "/usr/include/boost/asio.hpp" 2 3 4
># 1 "/usr/include/boost/asio/windows/stream_handle_service.hpp" 1 3 4
># 148 "/usr/include/boost/asio.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/write_at.hpp" 1 3 4
># 28 "/usr/include/boost/asio/write_at.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/write_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
># 79 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers);
># 123 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> boost::system::error_code& ec);
># 177 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition);
># 225 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec);
># 263 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b);
># 296 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, basic_streambuf<Allocator>& b,
> boost::system::error_code& ec);
># 339 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
># 383 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
> boost::system::error_code& ec);
># 457 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
> const ConstBufferSequence& buffers,
> WriteHandler&& handler);
># 536 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler);
># 593 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, WriteHandler&& handler);
># 659 "/usr/include/boost/asio/write_at.hpp" 3 4
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
> basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
> WriteHandler&& handler);
>
>
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 676 "/usr/include/boost/asio/write_at.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/impl/write_at.hpp" 1 3 4
># 33 "/usr/include/boost/asio/impl/write_at.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 34 "/usr/include/boost/asio/impl/write_at.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>
>namespace detail
>{
> template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename ConstBufferIterator, typename CompletionCondition>
> std::size_t write_at_buffer_sequence(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> const ConstBufferIterator&, CompletionCondition completion_condition,
> boost::system::error_code& ec)
> {
> ec = boost::system::error_code();
> boost::asio::detail::consuming_buffers<const_buffer,
> ConstBufferSequence, ConstBufferIterator> tmp(buffers);
> while (!tmp.empty())
> {
> if (std::size_t max_size = detail::adapt_completion_condition_result(
> completion_condition(ec, tmp.total_consumed())))
> {
> tmp.consume(d.write_some_at(offset + tmp.total_consumed(),
> tmp.prepare(max_size), ec));
> }
> else
> break;
> }
> return tmp.total_consumed();;
> }
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> return detail::write_at_buffer_sequence(d, offset, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition, ec);
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(
> d, offset, buffers, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
>{
> return write_at(d, offset, buffers, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(
> d, offset, buffers, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>
>
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition, boost::system::error_code& ec)
>{
> std::size_t bytes_transferred = write_at(
> d, offset, b.data(), completion_condition, ec);
> b.consume(bytes_transferred);
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(d, offset, b, transfer_all(), ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> boost::system::error_code& ec)
>{
> return write_at(d, offset, b, transfer_all(), ec);
>}
>
>template <typename SyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition>
>inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition)
>{
> boost::system::error_code ec;
> std::size_t bytes_transferred = write_at(
> d, offset, b, completion_condition, ec);
> boost::asio::detail::throw_error(ec, "write_at");
> return bytes_transferred;
>}
>
>
>
>
>namespace detail
>{
> template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> class write_at_op
> : detail::base_from_completion_cond<CompletionCondition>
> {
> public:
> write_at_op(AsyncRandomAccessWriteDevice& device,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition, WriteHandler& handler)
> : detail::base_from_completion_cond<
> CompletionCondition>(completion_condition),
> device_(device),
> offset_(offset),
> buffers_(buffers),
> start_(0),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_op(const write_at_op& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(other.handler_)
> {
> }
>
> write_at_op(write_at_op&& other)
> : detail::base_from_completion_cond<CompletionCondition>(other),
> device_(other.device_),
> offset_(other.offset_),
> buffers_(other.buffers_),
> start_(other.start_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> std::size_t bytes_transferred, int start = 0)
> {
> std::size_t max_size;
> switch (start_ = start)
> {
> case 1:
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> do
> {
> device_.async_write_some_at(
> offset_ + buffers_.total_consumed(), buffers_.prepare(max_size),
> static_cast<write_at_op&&>(*this));
> return; default:
> buffers_.consume(bytes_transferred);
> if ((!ec && bytes_transferred == 0) || buffers_.empty())
> break;
> max_size = this->check_for_completion(ec, buffers_.total_consumed());
> } while (max_size > 0);
>
> handler_(ec, buffers_.total_consumed());
> }
> }
>
>
> AsyncRandomAccessWriteDevice& device_;
> uint64_t offset_;
> boost::asio::detail::consuming_buffers<const_buffer,
> ConstBufferSequence, ConstBufferIterator> buffers_;
> int start_;
> WriteHandler handler_;
> };
>
> template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
> {
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler>
> inline void start_write_at_buffer_sequence_op(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> const ConstBufferIterator&, CompletionCondition completion_condition,
> WriteHandler& handler)
> {
> detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>(
> d, offset, buffers, completion_condition, handler)(
> boost::system::error_code(), 0, 1);
> }
>}
>
>
>
>template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler, typename Allocator>
>struct associated_allocator<
> detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>,
> Allocator>
>{
> typedef typename associated_allocator<WriteHandler, Allocator>::type type;
>
> static type get(
> const detail::write_at_op<AsyncRandomAccessWriteDevice,
> ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<WriteHandler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename AsyncRandomAccessWriteDevice,
> typename ConstBufferSequence, typename ConstBufferIterator,
> typename CompletionCondition, typename WriteHandler, typename Executor>
>struct associated_executor<
> detail::write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
> ConstBufferIterator, CompletionCondition, WriteHandler>,
> Executor>
>{
> typedef typename associated_executor<WriteHandler, Executor>::type type;
>
> static type get(
> const detail::write_at_op<AsyncRandomAccessWriteDevice,
> ConstBufferSequence, ConstBufferIterator,
> CompletionCondition, WriteHandler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<WriteHandler, Executor>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_write_at_buffer_sequence_op(d, offset, buffers,
> boost::asio::buffer_sequence_begin(buffers), completion_condition,
> init.completion_handler);
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
> typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, const ConstBufferSequence& buffers,
> WriteHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::start_write_at_buffer_sequence_op(d, offset, buffers,
> boost::asio::buffer_sequence_begin(buffers), transfer_all(),
> init.completion_handler);
>
> return init.result.get();
>}
>
>
>
>
>namespace detail
>{
> template <typename Allocator, typename WriteHandler>
> class write_at_streambuf_op
> {
> public:
> write_at_streambuf_op(
> boost::asio::basic_streambuf<Allocator>& streambuf,
> WriteHandler& handler)
> : streambuf_(streambuf),
> handler_(static_cast<WriteHandler&&>(handler))
> {
> }
>
>
> write_at_streambuf_op(const write_at_streambuf_op& other)
> : streambuf_(other.streambuf_),
> handler_(other.handler_)
> {
> }
>
> write_at_streambuf_op(write_at_streambuf_op&& other)
> : streambuf_(other.streambuf_),
> handler_(static_cast<WriteHandler&&>(other.handler_))
> {
> }
>
>
> void operator()(const boost::system::error_code& ec,
> const std::size_t bytes_transferred)
> {
> streambuf_.consume(bytes_transferred);
> handler_(ec, bytes_transferred);
> }
>
>
> boost::asio::basic_streambuf<Allocator>& streambuf_;
> WriteHandler handler_;
> };
>
> template <typename Allocator, typename WriteHandler>
> inline void* asio_handler_allocate(std::size_t size,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline void asio_handler_deallocate(void* pointer, std::size_t size,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline bool asio_handler_is_continuation(
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> return boost_asio_handler_cont_helpers::is_continuation(
> this_handler->handler_);
> }
>
> template <typename Function, typename Allocator, typename WriteHandler>
> inline void asio_handler_invoke(Function& function,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Function, typename Allocator, typename WriteHandler>
> inline void asio_handler_invoke(const Function& function,
> write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
> {
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
> }
>
> template <typename Allocator, typename WriteHandler>
> inline write_at_streambuf_op<Allocator, WriteHandler>
> make_write_at_streambuf_op(
> boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
> {
> return write_at_streambuf_op<Allocator, WriteHandler>(b, handler);
> }
>}
>
>
>
>template <typename Allocator, typename WriteHandler, typename Allocator1>
>struct associated_allocator<
> detail::write_at_streambuf_op<Allocator, WriteHandler>,
> Allocator1>
>{
> typedef typename associated_allocator<WriteHandler, Allocator1>::type type;
>
> static type get(
> const detail::write_at_streambuf_op<Allocator, WriteHandler>& h,
> const Allocator1& a = Allocator1()) noexcept
> {
> return associated_allocator<WriteHandler, Allocator1>::get(h.handler_, a);
> }
>};
>
>template <typename Executor, typename WriteHandler, typename Executor1>
>struct associated_executor<
> detail::write_at_streambuf_op<Executor, WriteHandler>,
> Executor1>
>{
> typedef typename associated_executor<WriteHandler, Executor1>::type type;
>
> static type get(
> const detail::write_at_streambuf_op<Executor, WriteHandler>& h,
> const Executor1& ex = Executor1()) noexcept
> {
> return associated_executor<WriteHandler, Executor1>::get(h.handler_, ex);
> }
>};
>
>
>
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename CompletionCondition, typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> CompletionCondition completion_condition,
> WriteHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> async_write_at(d, offset, b.data(), completion_condition,
> detail::write_at_streambuf_op<Allocator, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> b, init.completion_handler));
>
> return init.result.get();
>}
>
>template <typename AsyncRandomAccessWriteDevice, typename Allocator,
> typename WriteHandler>
>inline typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
>async_write_at(AsyncRandomAccessWriteDevice& d,
> uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
> WriteHandler&& handler)
>{
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> async_write_at(d, offset, b.data(), transfer_all(),
> detail::write_at_streambuf_op<Allocator, typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::completion_handler_type
> >(
> b, init.completion_handler));
>
> return init.result.get();
>}
>
>
>
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 573 "/usr/include/boost/asio/impl/write_at.hpp" 2 3 4
># 678 "/usr/include/boost/asio/write_at.hpp" 2 3 4
># 150 "/usr/include/boost/asio.hpp" 2 3 4
># 37 "/usr/local/include/nghttp2/asio_http2.h" 2 3
># 1 "/usr/include/boost/asio/ssl.hpp" 1 3 4
># 18 "/usr/include/boost/asio/ssl.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/context.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ssl/context.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/context_base.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ssl/context_base.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/detail/openssl_types.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ssl/detail/openssl_types.hpp" 3 4
># 1 "/usr/include/openssl/conf.h" 1 3 4
># 13 "/usr/include/openssl/conf.h" 3 4
># 1 "/usr/include/openssl/bio.h" 1 3 4
># 13 "/usr/include/openssl/bio.h" 3 4
># 1 "/usr/include/openssl/e_os2.h" 1 3 4
># 13 "/usr/include/openssl/e_os2.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/e_os2.h" 2 3 4
>
>
>extern "C" {
># 295 "/usr/include/openssl/e_os2.h" 3 4
>}
># 14 "/usr/include/openssl/bio.h" 2 3 4
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h" 1 3 4
># 19 "/usr/include/openssl/bio.h" 2 3 4
>
># 1 "/usr/include/openssl/crypto.h" 1 3 4
># 19 "/usr/include/openssl/crypto.h" 3 4
># 1 "/usr/include/c++/8/stdlib.h" 1 3 4
># 36 "/usr/include/c++/8/stdlib.h" 3 4
># 1 "/usr/include/c++/8/cstdlib" 1 3 4
># 39 "/usr/include/c++/8/cstdlib" 3 4
> 
># 40 "/usr/include/c++/8/cstdlib" 3
># 37 "/usr/include/c++/8/stdlib.h" 2 3 4
>
>using std::abort;
>using std::atexit;
>using std::exit;
>
>
> using std::at_quick_exit;
>
>
> using std::quick_exit;
>
>
>
>
>using std::div_t;
>using std::ldiv_t;
>
>using std::abs;
>using std::atof;
>using std::atoi;
>using std::atol;
>using std::bsearch;
>using std::calloc;
>using std::div;
>using std::free;
>using std::getenv;
>using std::labs;
>using std::ldiv;
>using std::malloc;
>
>using std::mblen;
>using std::mbstowcs;
>using std::mbtowc;
>
>using std::qsort;
>using std::rand;
>using std::realloc;
>using std::srand;
>using std::strtod;
>using std::strtol;
>using std::strtoul;
>using std::system;
>
>using std::wcstombs;
>using std::wctomb;
># 20 "/usr/include/openssl/crypto.h" 2 3 4
># 28 "/usr/include/openssl/crypto.h" 3 4
># 1 "/usr/include/openssl/stack.h" 1 3 4
># 14 "/usr/include/openssl/stack.h" 3 4
>extern "C" {
>
>
>typedef struct stack_st OPENSSL_STACK;
>
>typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
>typedef void (*OPENSSL_sk_freefunc)(void *);
>typedef void *(*OPENSSL_sk_copyfunc)(const void *);
>
>int OPENSSL_sk_num(const OPENSSL_STACK *);
>void *OPENSSL_sk_value(const OPENSSL_STACK *, int);
>
>void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data);
>
>OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp);
>OPENSSL_STACK *OPENSSL_sk_new_null(void);
>void OPENSSL_sk_free(OPENSSL_STACK *);
>void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *));
>OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *, OPENSSL_sk_copyfunc c, OPENSSL_sk_freefunc f);
>int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where);
>void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc);
>void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p);
>int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data);
>int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data);
>int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data);
>int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data);
>void *OPENSSL_sk_shift(OPENSSL_STACK *st);
>void *OPENSSL_sk_pop(OPENSSL_STACK *st);
>void OPENSSL_sk_zero(OPENSSL_STACK *st);
>OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, OPENSSL_sk_compfunc cmp);
>OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st);
>void OPENSSL_sk_sort(OPENSSL_STACK *st);
>int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st);
># 75 "/usr/include/openssl/stack.h" 3 4
>}
># 29 "/usr/include/openssl/crypto.h" 2 3 4
># 1 "/usr/include/openssl/safestack.h" 1 3 4
># 17 "/usr/include/openssl/safestack.h" 3 4
>extern "C" {
># 141 "/usr/include/openssl/safestack.h" 3 4
>typedef char *OPENSSL_STRING;
>typedef const char *OPENSSL_CSTRING;
># 151 "/usr/include/openssl/safestack.h" 3 4
>struct stack_st_OPENSSL_STRING; typedef int (*sk_OPENSSL_STRING_compfunc)(const char * const *a, const char *const *b); typedef void (*sk_OPENSSL_STRING_freefunc)(char *a); typedef char * (*sk_OPENSSL_STRING_copyfunc)(const char *a); static inline int sk_OPENSSL_STRING_num(const struct stack_st_OPENSSL_STRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline char *sk_OPENSSL_STRING_value(const struct stack_st_OPENSSL_STRING *sk, int idx) { return (char *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_new(sk_OPENSSL_STRING_compfunc compare) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_new_null(void) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_new_null(); } static inline void sk_OPENSSL_STRING_free(struct stack_st_OPENSSL_STRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_OPENSSL_STRING_zero(struct stack_st_OPENSSL_STRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline char *sk_OPENSSL_STRING_delete(struct stack_st_OPENSSL_STRING *sk, int i) { return (char *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline char *sk_OPENSSL_STRING_delete_ptr(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return (char *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_STRING_push(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_STRING_unshift(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline char *sk_OPENSSL_STRING_pop(struct stack_st_OPENSSL_STRING *sk) { return (char *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline char *sk_OPENSSL_STRING_shift(struct stack_st_OPENSSL_STRING *sk) { return (char *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_OPENSSL_STRING_pop_free(struct stack_st_OPENSSL_STRING *sk, sk_OPENSSL_STRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_OPENSSL_STRING_insert(struct stack_st_OPENSSL_STRING *sk, char *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline char *sk_OPENSSL_STRING_set(struct stack_st_OPENSSL_STRING *sk, int idx, char *ptr) { return (char *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_OPENSSL_STRING_find(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_STRING_find_ex(struct stack_st_OPENSSL_STRING *sk, char *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_OPENSSL_STRING_sort(struct stack_st_OPENSSL_STRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_OPENSSL_STRING_is_sorted(const struct stack_st_OPENSSL_STRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_OPENSSL_STRING * sk_OPENSSL_STRING_dup(const struct stack_st_OPENSSL_STRING *sk) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_OPENSSL_STRING *sk_OPENSSL_STRING_deep_copy(const struct stack_st_OPENSSL_STRING *sk, sk_OPENSSL_STRING_copyfunc copyfunc, sk_OPENSSL_STRING_freefunc freefunc) { return (struct stack_st_OPENSSL_STRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_OPENSSL_STRING_compfunc sk_OPENSSL_STRING_set_cmp_func(struct stack_st_OPENSSL_STRING *sk, sk_OPENSSL_STRING_compfunc compare) { return (sk_OPENSSL_STRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct stack_st_OPENSSL_CSTRING; typedef int (*sk_OPENSSL_CSTRING_compfunc)(const char * const *a, const char *const *b); typedef void (*sk_OPENSSL_CSTRING_freefunc)(char *a); typedef char * (*sk_OPENSSL_CSTRING_copyfunc)(const char *a); static inline int sk_OPENSSL_CSTRING_num(const struct stack_st_OPENSSL_CSTRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline const char *sk_OPENSSL_CSTRING_value(const struct stack_st_OPENSSL_CSTRING *sk, int idx) { return (const char *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_new(sk_OPENSSL_CSTRING_compfunc compare) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_new_null(void) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_new_null(); } static inline void sk_OPENSSL_CSTRING_free(struct stack_st_OPENSSL_CSTRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_OPENSSL_CSTRING_zero(struct stack_st_OPENSSL_CSTRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline const char *sk_OPENSSL_CSTRING_delete(struct stack_st_OPENSSL_CSTRING *sk, int i) { return (const char *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline const char *sk_OPENSSL_CSTRING_delete_ptr(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return (const char *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_CSTRING_push(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_CSTRING_unshift(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline const char *sk_OPENSSL_CSTRING_pop(struct stack_st_OPENSSL_CSTRING *sk) { return (const char *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline const char *sk_OPENSSL_CSTRING_shift(struct stack_st_OPENSSL_CSTRING *sk) { return (const char *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_OPENSSL_CSTRING_pop_free(struct stack_st_OPENSSL_CSTRING *sk, sk_OPENSSL_CSTRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_OPENSSL_CSTRING_insert(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline const char *sk_OPENSSL_CSTRING_set(struct stack_st_OPENSSL_CSTRING *sk, int idx, const char *ptr) { return (const char *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_OPENSSL_CSTRING_find(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_CSTRING_find_ex(struct stack_st_OPENSSL_CSTRING *sk, const char *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_OPENSSL_CSTRING_sort(struct stack_st_OPENSSL_CSTRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_OPENSSL_CSTRING_is_sorted(const struct stack_st_OPENSSL_CSTRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_OPENSSL_CSTRING * sk_OPENSSL_CSTRING_dup(const struct stack_st_OPENSSL_CSTRING *sk) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_OPENSSL_CSTRING *sk_OPENSSL_CSTRING_deep_copy(const struct stack_st_OPENSSL_CSTRING *sk, sk_OPENSSL_CSTRING_copyfunc copyfunc, sk_OPENSSL_CSTRING_freefunc freefunc) { return (struct stack_st_OPENSSL_CSTRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_OPENSSL_CSTRING_compfunc sk_OPENSSL_CSTRING_set_cmp_func(struct stack_st_OPENSSL_CSTRING *sk, sk_OPENSSL_CSTRING_compfunc compare) { return (sk_OPENSSL_CSTRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>
>
>typedef void *OPENSSL_BLOCK;
>struct stack_st_OPENSSL_BLOCK; typedef int (*sk_OPENSSL_BLOCK_compfunc)(const void * const *a, const void *const *b); typedef void (*sk_OPENSSL_BLOCK_freefunc)(void *a); typedef void * (*sk_OPENSSL_BLOCK_copyfunc)(const void *a); static inline int sk_OPENSSL_BLOCK_num(const struct stack_st_OPENSSL_BLOCK *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline void *sk_OPENSSL_BLOCK_value(const struct stack_st_OPENSSL_BLOCK *sk, int idx) { return (void *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_new(sk_OPENSSL_BLOCK_compfunc compare) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_new_null(void) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_new_null(); } static inline void sk_OPENSSL_BLOCK_free(struct stack_st_OPENSSL_BLOCK *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_OPENSSL_BLOCK_zero(struct stack_st_OPENSSL_BLOCK *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline void *sk_OPENSSL_BLOCK_delete(struct stack_st_OPENSSL_BLOCK *sk, int i) { return (void *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline void *sk_OPENSSL_BLOCK_delete_ptr(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return (void *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_BLOCK_push(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_BLOCK_unshift(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void *sk_OPENSSL_BLOCK_pop(struct stack_st_OPENSSL_BLOCK *sk) { return (void *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline void *sk_OPENSSL_BLOCK_shift(struct stack_st_OPENSSL_BLOCK *sk) { return (void *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_OPENSSL_BLOCK_pop_free(struct stack_st_OPENSSL_BLOCK *sk, sk_OPENSSL_BLOCK_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_OPENSSL_BLOCK_insert(struct stack_st_OPENSSL_BLOCK *sk, void *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline void *sk_OPENSSL_BLOCK_set(struct stack_st_OPENSSL_BLOCK *sk, int idx, void *ptr) { return (void *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_OPENSSL_BLOCK_find(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_OPENSSL_BLOCK_find_ex(struct stack_st_OPENSSL_BLOCK *sk, void *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_OPENSSL_BLOCK_sort(struct stack_st_OPENSSL_BLOCK *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_OPENSSL_BLOCK_is_sorted(const struct stack_st_OPENSSL_BLOCK *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_OPENSSL_BLOCK * sk_OPENSSL_BLOCK_dup(const struct stack_st_OPENSSL_BLOCK *sk) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_OPENSSL_BLOCK *sk_OPENSSL_BLOCK_deep_copy(const struct stack_st_OPENSSL_BLOCK *sk, sk_OPENSSL_BLOCK_copyfunc copyfunc, sk_OPENSSL_BLOCK_freefunc freefunc) { return (struct stack_st_OPENSSL_BLOCK *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_OPENSSL_BLOCK_compfunc sk_OPENSSL_BLOCK_set_cmp_func(struct stack_st_OPENSSL_BLOCK *sk, sk_OPENSSL_BLOCK_compfunc compare) { return (sk_OPENSSL_BLOCK_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>}
># 30 "/usr/include/openssl/crypto.h" 2 3 4
># 1 "/usr/include/openssl/opensslv.h" 1 3 4
># 14 "/usr/include/openssl/opensslv.h" 3 4
>extern "C" {
># 108 "/usr/include/openssl/opensslv.h" 3 4
>}
># 31 "/usr/include/openssl/crypto.h" 2 3 4
># 1 "/usr/include/openssl/ossl_typ.h" 1 3 4
># 13 "/usr/include/openssl/ossl_typ.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h" 1 3 4
># 14 "/usr/include/openssl/ossl_typ.h" 2 3 4
>
>
>extern "C" {
># 40 "/usr/include/openssl/ossl_typ.h" 3 4
>typedef struct asn1_string_st ASN1_INTEGER;
>typedef struct asn1_string_st ASN1_ENUMERATED;
>typedef struct asn1_string_st ASN1_BIT_STRING;
>typedef struct asn1_string_st ASN1_OCTET_STRING;
>typedef struct asn1_string_st ASN1_PRINTABLESTRING;
>typedef struct asn1_string_st ASN1_T61STRING;
>typedef struct asn1_string_st ASN1_IA5STRING;
>typedef struct asn1_string_st ASN1_GENERALSTRING;
>typedef struct asn1_string_st ASN1_UNIVERSALSTRING;
>typedef struct asn1_string_st ASN1_BMPSTRING;
>typedef struct asn1_string_st ASN1_UTCTIME;
>typedef struct asn1_string_st ASN1_TIME;
>typedef struct asn1_string_st ASN1_GENERALIZEDTIME;
>typedef struct asn1_string_st ASN1_VISIBLESTRING;
>typedef struct asn1_string_st ASN1_UTF8STRING;
>typedef struct asn1_string_st ASN1_STRING;
>typedef int ASN1_BOOLEAN;
>typedef int ASN1_NULL;
>
>
>typedef struct asn1_object_st ASN1_OBJECT;
>
>typedef struct ASN1_ITEM_st ASN1_ITEM;
>typedef struct asn1_pctx_st ASN1_PCTX;
>typedef struct asn1_sctx_st ASN1_SCTX;
># 78 "/usr/include/openssl/ossl_typ.h" 3 4
>struct dane_st;
>typedef struct bio_st BIO;
>typedef struct bignum_st BIGNUM;
>typedef struct bignum_ctx BN_CTX;
>typedef struct bn_blinding_st BN_BLINDING;
>typedef struct bn_mont_ctx_st BN_MONT_CTX;
>typedef struct bn_recp_ctx_st BN_RECP_CTX;
>typedef struct bn_gencb_st BN_GENCB;
>
>typedef struct buf_mem_st BUF_MEM;
>
>typedef struct evp_cipher_st EVP_CIPHER;
>typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX;
>typedef struct evp_md_st EVP_MD;
>typedef struct evp_md_ctx_st EVP_MD_CTX;
>typedef struct evp_pkey_st EVP_PKEY;
>
>typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD;
>
>typedef struct evp_pkey_method_st EVP_PKEY_METHOD;
>typedef struct evp_pkey_ctx_st EVP_PKEY_CTX;
>
>typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX;
>
>typedef struct hmac_ctx_st HMAC_CTX;
>
>typedef struct dh_st DH;
>typedef struct dh_method DH_METHOD;
>
>typedef struct dsa_st DSA;
>typedef struct dsa_method DSA_METHOD;
>
>typedef struct rsa_st RSA;
>typedef struct rsa_meth_st RSA_METHOD;
>
>typedef struct ec_key_st EC_KEY;
>typedef struct ec_key_method_st EC_KEY_METHOD;
>
>typedef struct rand_meth_st RAND_METHOD;
>
>typedef struct ssl_dane_st SSL_DANE;
>typedef struct x509_st X509;
>typedef struct X509_algor_st X509_ALGOR;
>typedef struct X509_crl_st X509_CRL;
>typedef struct x509_crl_method_st X509_CRL_METHOD;
>typedef struct x509_revoked_st X509_REVOKED;
>typedef struct X509_name_st X509_NAME;
>typedef struct X509_pubkey_st X509_PUBKEY;
>typedef struct x509_store_st X509_STORE;
>typedef struct x509_store_ctx_st X509_STORE_CTX;
>
>typedef struct x509_object_st X509_OBJECT;
>typedef struct x509_lookup_st X509_LOOKUP;
>typedef struct x509_lookup_method_st X509_LOOKUP_METHOD;
>typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM;
>
>typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
>
>typedef struct v3_ext_ctx X509V3_CTX;
>typedef struct conf_st CONF;
>typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS;
>
>typedef struct ui_st UI;
>typedef struct ui_method_st UI_METHOD;
>
>typedef struct engine_st ENGINE;
>typedef struct ssl_st SSL;
>typedef struct ssl_ctx_st SSL_CTX;
>
>typedef struct comp_ctx_st COMP_CTX;
>typedef struct comp_method_st COMP_METHOD;
>
>typedef struct X509_POLICY_NODE_st X509_POLICY_NODE;
>typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL;
>typedef struct X509_POLICY_TREE_st X509_POLICY_TREE;
>typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE;
>
>typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID;
>typedef struct DIST_POINT_st DIST_POINT;
>typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT;
>typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS;
>
>typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
>
>typedef struct ocsp_req_ctx_st OCSP_REQ_CTX;
>typedef struct ocsp_response_st OCSP_RESPONSE;
>typedef struct ocsp_responder_id_st OCSP_RESPID;
>
>typedef struct sct_st SCT;
>typedef struct sct_ctx_st SCT_CTX;
>typedef struct ctlog_st CTLOG;
>typedef struct ctlog_store_st CTLOG_STORE;
>typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX;
># 183 "/usr/include/openssl/ossl_typ.h" 3 4
>typedef long ossl_intmax_t;
>typedef unsigned long ossl_uintmax_t;
>
>
>
>}
># 32 "/usr/include/openssl/crypto.h" 2 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 33 "/usr/include/openssl/crypto.h" 2 3 4
># 42 "/usr/include/openssl/crypto.h" 3 4
># 1 "/usr/include/openssl/symhacks.h" 1 3 4
># 43 "/usr/include/openssl/crypto.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
># 66 "/usr/include/openssl/crypto.h" 3 4
>typedef struct {
> int dummy;
>} CRYPTO_dynlock;
>
>
>
>typedef void CRYPTO_RWLOCK;
>
>CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
>int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
>int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
>int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
>void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
>
>int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
># 91 "/usr/include/openssl/crypto.h" 3 4
>struct crypto_ex_data_st {
> struct stack_st_void *sk;
>};
>struct stack_st_void; typedef int (*sk_void_compfunc)(const void * const *a, const void *const *b); typedef void (*sk_void_freefunc)(void *a); typedef void * (*sk_void_copyfunc)(const void *a); static inline int sk_void_num(const struct stack_st_void *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline void *sk_void_value(const struct stack_st_void *sk, int idx) { return (void *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_void *sk_void_new(sk_void_compfunc compare) { return (struct stack_st_void *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_void *sk_void_new_null(void) { return (struct stack_st_void *)OPENSSL_sk_new_null(); } static inline void sk_void_free(struct stack_st_void *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_void_zero(struct stack_st_void *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline void *sk_void_delete(struct stack_st_void *sk, int i) { return (void *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline void *sk_void_delete_ptr(struct stack_st_void *sk, void *ptr) { return (void *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_void_push(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_void_unshift(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void *sk_void_pop(struct stack_st_void *sk) { return (void *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline void *sk_void_shift(struct stack_st_void *sk) { return (void *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_void_pop_free(struct stack_st_void *sk, sk_void_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_void_insert(struct stack_st_void *sk, void *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline void *sk_void_set(struct stack_st_void *sk, int idx, void *ptr) { return (void *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_void_find(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_void_find_ex(struct stack_st_void *sk, void *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_void_sort(struct stack_st_void *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_void_is_sorted(const struct stack_st_void *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_void * sk_void_dup(const struct stack_st_void *sk) { return (struct stack_st_void *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_void *sk_void_deep_copy(const struct stack_st_void *sk, sk_void_copyfunc copyfunc, sk_void_freefunc freefunc) { return (struct stack_st_void *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_void_compfunc sk_void_set_cmp_func(struct stack_st_void *sk, sk_void_compfunc compare) { return (sk_void_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 123 "/usr/include/openssl/crypto.h" 3 4
>int CRYPTO_mem_ctrl(int mode);
># 154 "/usr/include/openssl/crypto.h" 3 4
>size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
>size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
>size_t OPENSSL_strnlen(const char *str, size_t maxlen);
>char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len);
>unsigned char *OPENSSL_hexstr2buf(const char *str, long *len);
>int OPENSSL_hexchar2int(unsigned char c);
>
>
>
>unsigned long OpenSSL_version_num(void);
>const char *OpenSSL_version(int type);
>
>
>
>
>
>
>
>int OPENSSL_issetugid(void);
>
>typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
> int idx, long argl, void *argp);
>typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad,
> int idx, long argl, void *argp);
>typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
> void *from_d, int idx, long argl, void *argp);
> int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
> CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
> CRYPTO_EX_free *free_func);
>
>int CRYPTO_free_ex_index(int class_index, int idx);
>
>
>
>
>
>int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
>int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
> const CRYPTO_EX_DATA *from);
>
>void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
>
>
>
>
>
>int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
>void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
># 237 "/usr/include/openssl/crypto.h" 3 4
>typedef struct crypto_threadid_st {
> int dummy;
>} CRYPTO_THREADID;
># 264 "/usr/include/openssl/crypto.h" 3 4
>int CRYPTO_set_mem_functions(
> void *(*m) (size_t, const char *, int),
> void *(*r) (void *, size_t, const char *, int),
> void (*f) (void *, const char *, int));
>int CRYPTO_set_mem_debug(int flag);
>void CRYPTO_get_mem_functions(
> void *(**m) (size_t, const char *, int),
> void *(**r) (void *, size_t, const char *, int),
> void (**f) (void *, const char *, int));
>
>void *CRYPTO_malloc(size_t num, const char *file, int line);
>void *CRYPTO_zalloc(size_t num, const char *file, int line);
>void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
>char *CRYPTO_strdup(const char *str, const char *file, int line);
>char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
>void CRYPTO_free(void *ptr, const char *file, int line);
>void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
>void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
>void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
> const char *file, int line);
>
>int CRYPTO_secure_malloc_init(size_t sz, int minsize);
>int CRYPTO_secure_malloc_done(void);
>void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
>void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
>void CRYPTO_secure_free(void *ptr, const char *file, int line);
>void CRYPTO_secure_clear_free(void *ptr, size_t num,
> const char *file, int line);
>int CRYPTO_secure_allocated(const void *ptr);
>int CRYPTO_secure_malloc_initialized(void);
>size_t CRYPTO_secure_actual_size(void *ptr);
>size_t CRYPTO_secure_used(void);
>
>void OPENSSL_cleanse(void *ptr, size_t len);
># 327 "/usr/include/openssl/crypto.h" 3 4
>__attribute__((noreturn)) void OPENSSL_die(const char *assertion, const char *file, int line);
>
>
>
>
>
>
>int OPENSSL_isservice(void);
>
>int FIPS_mode(void);
>int FIPS_mode_set(int r);
>
>
>
>void FIPS_selftest_check(void);
>
>
>void OPENSSL_init(void);
>
>struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
>int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
>int OPENSSL_gmtime_diff(int *pday, int *psec,
> const struct tm *from, const struct tm *to);
># 358 "/usr/include/openssl/crypto.h" 3 4
>int CRYPTO_memcmp(const volatile void * volatile in_a,
> const volatile void * volatile in_b,
> size_t len);
># 391 "/usr/include/openssl/crypto.h" 3 4
>void OPENSSL_cleanup(void);
>int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
>int OPENSSL_atexit(void (*handler)(void));
>void OPENSSL_thread_stop(void);
>
>
>OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);
>
>int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
> const char *config_file);
>
>void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
># 416 "/usr/include/openssl/crypto.h" 3 4
>typedef pthread_once_t CRYPTO_ONCE;
>typedef pthread_key_t CRYPTO_THREAD_LOCAL;
>typedef pthread_t CRYPTO_THREAD_ID;
># 431 "/usr/include/openssl/crypto.h" 3 4
>int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));
>
>int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
>void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
>int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
>int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);
>
>CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
>int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
>
>
>
>
>
>
>
>int ERR_load_CRYPTO_strings(void);
># 470 "/usr/include/openssl/crypto.h" 3 4
>}
># 21 "/usr/include/openssl/bio.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
># 175 "/usr/include/openssl/bio.h" 3 4
>typedef union bio_addr_st BIO_ADDR;
>typedef struct bio_addrinfo_st BIO_ADDRINFO;
>
>int BIO_get_new_index(void);
>void BIO_set_flags(BIO *b, int flags);
>int BIO_test_flags(const BIO *b, int flags);
>void BIO_clear_flags(BIO *b, int flags);
># 237 "/usr/include/openssl/bio.h" 3 4
>typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
> long argl, long ret);
>BIO_callback_fn BIO_get_callback(const BIO *b);
>void BIO_set_callback(BIO *b, BIO_callback_fn callback);
>char *BIO_get_callback_arg(const BIO *b);
>void BIO_set_callback_arg(BIO *b, char *arg);
>
>typedef struct bio_method_st BIO_METHOD;
>
>const char *BIO_method_name(const BIO *b);
>int BIO_method_type(const BIO *b);
>
>typedef int BIO_info_cb(BIO *, int, int);
>typedef BIO_info_cb bio_info_cb;
>
>struct stack_st_BIO; typedef int (*sk_BIO_compfunc)(const BIO * const *a, const BIO *const *b); typedef void (*sk_BIO_freefunc)(BIO *a); typedef BIO * (*sk_BIO_copyfunc)(const BIO *a); static inline int sk_BIO_num(const struct stack_st_BIO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline BIO *sk_BIO_value(const struct stack_st_BIO *sk, int idx) { return (BIO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_BIO *sk_BIO_new(sk_BIO_compfunc compare) { return (struct stack_st_BIO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_BIO *sk_BIO_new_null(void) { return (struct stack_st_BIO *)OPENSSL_sk_new_null(); } static inline void sk_BIO_free(struct stack_st_BIO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_BIO_zero(struct stack_st_BIO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline BIO *sk_BIO_delete(struct stack_st_BIO *sk, int i) { return (BIO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline BIO *sk_BIO_delete_ptr(struct stack_st_BIO *sk, BIO *ptr) { return (BIO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_BIO_push(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_BIO_unshift(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline BIO *sk_BIO_pop(struct stack_st_BIO *sk) { return (BIO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline BIO *sk_BIO_shift(struct stack_st_BIO *sk) { return (BIO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_BIO_pop_free(struct stack_st_BIO *sk, sk_BIO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_BIO_insert(struct stack_st_BIO *sk, BIO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline BIO *sk_BIO_set(struct stack_st_BIO *sk, int idx, BIO *ptr) { return (BIO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_BIO_find(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_BIO_find_ex(struct stack_st_BIO *sk, BIO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_BIO_sort(struct stack_st_BIO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_BIO_is_sorted(const struct stack_st_BIO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_BIO * sk_BIO_dup(const struct stack_st_BIO *sk) { return (struct stack_st_BIO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_BIO *sk_BIO_deep_copy(const struct stack_st_BIO *sk, sk_BIO_copyfunc copyfunc, sk_BIO_freefunc freefunc) { return (struct stack_st_BIO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_BIO_compfunc sk_BIO_set_cmp_func(struct stack_st_BIO *sk, sk_BIO_compfunc compare) { return (sk_BIO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen,
> void *parg);
>
>
>
>struct bio_dgram_sctp_sndinfo {
> uint16_t snd_sid;
> uint16_t snd_flags;
> uint32_t snd_ppid;
> uint32_t snd_context;
>};
>
>struct bio_dgram_sctp_rcvinfo {
> uint16_t rcv_sid;
> uint16_t rcv_ssn;
> uint16_t rcv_flags;
> uint32_t rcv_ppid;
> uint32_t rcv_tsn;
> uint32_t rcv_cumtsn;
> uint32_t rcv_context;
>};
>
>struct bio_dgram_sctp_prinfo {
> uint16_t pr_policy;
> uint32_t pr_value;
>};
># 474 "/usr/include/openssl/bio.h" 3 4
>size_t BIO_ctrl_pending(BIO *b);
>size_t BIO_ctrl_wpending(BIO *b);
># 493 "/usr/include/openssl/bio.h" 3 4
>size_t BIO_ctrl_get_write_guarantee(BIO *b);
>size_t BIO_ctrl_get_read_request(BIO *b);
>int BIO_ctrl_reset_read_request(BIO *b);
># 515 "/usr/include/openssl/bio.h" 3 4
>int BIO_set_ex_data(BIO *bio, int idx, void *data);
>void *BIO_get_ex_data(BIO *bio, int idx);
>uint64_t BIO_number_read(BIO *bio);
>uint64_t BIO_number_written(BIO *bio);
>
>
>int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
> asn1_ps_func *prefix_free);
>int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
> asn1_ps_func **pprefix_free);
>int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
> asn1_ps_func *suffix_free);
>int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
> asn1_ps_func **psuffix_free);
>
>const BIO_METHOD *BIO_s_file(void);
>BIO *BIO_new_file(const char *filename, const char *mode);
>
>BIO *BIO_new_fp(FILE *stream, int close_flag);
>
>BIO *BIO_new(const BIO_METHOD *type);
>int BIO_free(BIO *a);
>void BIO_set_data(BIO *a, void *ptr);
>void *BIO_get_data(BIO *a);
>void BIO_set_init(BIO *a, int init);
>int BIO_get_init(BIO *a);
>void BIO_set_shutdown(BIO *a, int shut);
>int BIO_get_shutdown(BIO *a);
>void BIO_vfree(BIO *a);
>int BIO_up_ref(BIO *a);
>int BIO_read(BIO *b, void *data, int len);
>int BIO_gets(BIO *bp, char *buf, int size);
>int BIO_write(BIO *b, const void *data, int len);
>int BIO_puts(BIO *bp, const char *buf);
>int BIO_indent(BIO *b, int indent, int max);
>long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
>long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
>void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
>long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
>BIO *BIO_push(BIO *b, BIO *append);
>BIO *BIO_pop(BIO *b);
>void BIO_free_all(BIO *a);
>BIO *BIO_find_type(BIO *b, int bio_type);
>BIO *BIO_next(BIO *b);
>void BIO_set_next(BIO *b, BIO *next);
>BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
>int BIO_get_retry_reason(BIO *bio);
>void BIO_set_retry_reason(BIO *bio, int reason);
>BIO *BIO_dup_chain(BIO *in);
>
>int BIO_nread0(BIO *bio, char **buf);
>int BIO_nread(BIO *bio, char **buf, int num);
>int BIO_nwrite0(BIO *bio, char **buf);
>int BIO_nwrite(BIO *bio, char **buf, int num);
>
>long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi,
> long argl, long ret);
>
>const BIO_METHOD *BIO_s_mem(void);
>const BIO_METHOD *BIO_s_secmem(void);
>BIO *BIO_new_mem_buf(const void *buf, int len);
>
>const BIO_METHOD *BIO_s_socket(void);
>const BIO_METHOD *BIO_s_connect(void);
>const BIO_METHOD *BIO_s_accept(void);
>
>const BIO_METHOD *BIO_s_fd(void);
>const BIO_METHOD *BIO_s_log(void);
>const BIO_METHOD *BIO_s_bio(void);
>const BIO_METHOD *BIO_s_null(void);
>const BIO_METHOD *BIO_f_null(void);
>const BIO_METHOD *BIO_f_buffer(void);
>const BIO_METHOD *BIO_f_linebuffer(void);
>const BIO_METHOD *BIO_f_nbio_test(void);
>
>const BIO_METHOD *BIO_s_datagram(void);
>int BIO_dgram_non_fatal_error(int error);
>BIO *BIO_new_dgram(int fd, int close_flag);
>
>const BIO_METHOD *BIO_s_datagram_sctp(void);
>BIO *BIO_new_dgram_sctp(int fd, int close_flag);
>int BIO_dgram_is_sctp(BIO *bio);
>int BIO_dgram_sctp_notification_cb(BIO *b,
> void (*handle_notifications) (BIO *bio,
> void *context,
> void *buf),
> void *context);
>int BIO_dgram_sctp_wait_for_dry(BIO *b);
>int BIO_dgram_sctp_msg_waiting(BIO *b);
>
>
>
>
>int BIO_sock_should_retry(int i);
>int BIO_sock_non_fatal_error(int error);
>
>
>int BIO_fd_should_retry(int i);
>int BIO_fd_non_fatal_error(int error);
>int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u),
> void *u, const char *s, int len);
>int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u),
> void *u, const char *s, int len, int indent);
>int BIO_dump(BIO *b, const char *bytes, int len);
>int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent);
>
>int BIO_dump_fp(FILE *fp, const char *s, int len);
>int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent);
>
>int BIO_hex_string(BIO *out, int indent, int width, unsigned char *data,
> int datalen);
>
>
>BIO_ADDR *BIO_ADDR_new(void);
>int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
> const void *where, size_t wherelen, unsigned short port);
>void BIO_ADDR_free(BIO_ADDR *);
>void BIO_ADDR_clear(BIO_ADDR *ap);
>int BIO_ADDR_family(const BIO_ADDR *ap);
>int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
>unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
>char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
>char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
>char *BIO_ADDR_path_string(const BIO_ADDR *ap);
>
>const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
>int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
>int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
>int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
>const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
>void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);
>
>enum BIO_hostserv_priorities {
> BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV
>};
>int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
> enum BIO_hostserv_priorities hostserv_prio);
>enum BIO_lookup_type {
> BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER
>};
>int BIO_lookup(const char *host, const char *service,
> enum BIO_lookup_type lookup_type,
> int family, int socktype, BIO_ADDRINFO **res);
>int BIO_sock_error(int sock);
>int BIO_socket_ioctl(int fd, long type, void *arg);
>int BIO_socket_nbio(int fd, int mode);
>int BIO_sock_init(void);
>
>
>
>int BIO_set_tcp_ndelay(int sock, int turn_on);
>
>struct hostent *BIO_gethostbyname(const char *name) __attribute__ ((deprecated));
>int BIO_get_port(const char *str, unsigned short *port_ptr) __attribute__ ((deprecated));
>int BIO_get_host_ip(const char *str, unsigned char *ip) __attribute__ ((deprecated));
>int BIO_get_accept_socket(char *host_port, int mode) __attribute__ ((deprecated));
>int BIO_accept(int sock, char **ip_port) __attribute__ ((deprecated));
>
>union BIO_sock_info_u {
> BIO_ADDR *addr;
>};
>enum BIO_sock_info_type {
> BIO_SOCK_INFO_ADDRESS
>};
>int BIO_sock_info(int sock,
> enum BIO_sock_info_type type, union BIO_sock_info_u *info);
>
>
>
>
>
>
>
>int BIO_socket(int domain, int socktype, int protocol, int options);
>int BIO_connect(int sock, const BIO_ADDR *addr, int options);
>int BIO_listen(int sock, const BIO_ADDR *addr, int options);
>int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
>int BIO_closesocket(int sock);
>
>BIO *BIO_new_socket(int sock, int close_flag);
>BIO *BIO_new_connect(const char *host_port);
>BIO *BIO_new_accept(const char *host_port);
>
>
>BIO *BIO_new_fd(int fd, int close_flag);
>
>int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
> BIO **bio2, size_t writebuf2);
>
>
>
>
>
>
>void BIO_copy_next_retry(BIO *b);
># 720 "/usr/include/openssl/bio.h" 3 4
>int BIO_printf(BIO *bio, const char *format, ...)
>__attribute__((__format__(__printf__, 2, 3)));
>int BIO_vprintf(BIO *bio, const char *format, va_list args)
>__attribute__((__format__(__printf__, 2, 0)));
>int BIO_snprintf(char *buf, size_t n, const char *format, ...)
>__attribute__((__format__(__printf__, 3, 4)));
>int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
>__attribute__((__format__(__printf__, 3, 0)));
>
>
>
>BIO_METHOD *BIO_meth_new(int type, const char *name);
>void BIO_meth_free(BIO_METHOD *biom);
>int (*BIO_meth_get_write(BIO_METHOD *biom)) (BIO *, const char *, int);
>int BIO_meth_set_write(BIO_METHOD *biom,
> int (*write) (BIO *, const char *, int));
>int (*BIO_meth_get_read(BIO_METHOD *biom)) (BIO *, char *, int);
>int BIO_meth_set_read(BIO_METHOD *biom,
> int (*read) (BIO *, char *, int));
>int (*BIO_meth_get_puts(BIO_METHOD *biom)) (BIO *, const char *);
>int BIO_meth_set_puts(BIO_METHOD *biom,
> int (*puts) (BIO *, const char *));
>int (*BIO_meth_get_gets(BIO_METHOD *biom)) (BIO *, char *, int);
>int BIO_meth_set_gets(BIO_METHOD *biom,
> int (*gets) (BIO *, char *, int));
>long (*BIO_meth_get_ctrl(BIO_METHOD *biom)) (BIO *, int, long, void *);
>int BIO_meth_set_ctrl(BIO_METHOD *biom,
> long (*ctrl) (BIO *, int, long, void *));
>int (*BIO_meth_get_create(BIO_METHOD *bion)) (BIO *);
>int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *));
>int (*BIO_meth_get_destroy(BIO_METHOD *biom)) (BIO *);
>int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *));
>long (*BIO_meth_get_callback_ctrl(BIO_METHOD *biom))
> (BIO *, int, BIO_info_cb *);
>int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
> long (*callback_ctrl) (BIO *, int,
> BIO_info_cb *));
>
>
>
>
>
>
>
>int ERR_load_BIO_strings(void);
># 850 "/usr/include/openssl/bio.h" 3 4
>}
># 14 "/usr/include/openssl/conf.h" 2 3 4
># 1 "/usr/include/openssl/lhash.h" 1 3 4
># 21 "/usr/include/openssl/lhash.h" 3 4
>extern "C" {
>
>
>typedef struct lhash_node_st OPENSSL_LH_NODE;
>typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *);
>typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *);
>typedef void (*OPENSSL_LH_DOALL_FUNC) (void *);
>typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *);
>typedef struct lhash_st OPENSSL_LHASH;
># 72 "/usr/include/openssl/lhash.h" 3 4
>int OPENSSL_LH_error(OPENSSL_LHASH *lh);
>OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c);
>void OPENSSL_LH_free(OPENSSL_LHASH *lh);
>void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data);
>void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data);
>void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data);
>void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func);
>void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg);
>unsigned long OPENSSL_LH_strhash(const char *c);
>unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh);
>unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh);
>void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load);
>
>
>void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp);
>void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp);
>void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp);
>
>void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
>void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
>void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out);
># 197 "/usr/include/openssl/lhash.h" 3 4
>struct lhash_st_OPENSSL_STRING { union lh_OPENSSL_STRING_dummy { void* d1; unsigned long d2; int d3; } dummy; }; static inline struct lhash_st_OPENSSL_STRING * lh_OPENSSL_STRING_new(unsigned long (*hfn)(const OPENSSL_STRING *), int (*cfn)(const OPENSSL_STRING *, const OPENSSL_STRING *)) { return (struct lhash_st_OPENSSL_STRING *) OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); } static inline void lh_OPENSSL_STRING_free(struct lhash_st_OPENSSL_STRING *lh) { OPENSSL_LH_free((OPENSSL_LHASH *)lh); } static inline OPENSSL_STRING *lh_OPENSSL_STRING_insert(struct lhash_st_OPENSSL_STRING *lh, OPENSSL_STRING *d) { return (OPENSSL_STRING *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); } static inline OPENSSL_STRING *lh_OPENSSL_STRING_delete(struct lhash_st_OPENSSL_STRING *lh, const OPENSSL_STRING *d) { return (OPENSSL_STRING *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); } static inline OPENSSL_STRING *lh_OPENSSL_STRING_retrieve(struct lhash_st_OPENSSL_STRING *lh, const OPENSSL_STRING *d) { return (OPENSSL_STRING *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); } static inline int lh_OPENSSL_STRING_error(struct lhash_st_OPENSSL_STRING *lh) { return OPENSSL_LH_error((OPENSSL_LHASH *)lh); } static inline unsigned long lh_OPENSSL_STRING_num_items(struct lhash_st_OPENSSL_STRING *lh) { return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); } static inline void lh_OPENSSL_STRING_node_stats_bio(const struct lhash_st_OPENSSL_STRING *lh, BIO *out) { OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_OPENSSL_STRING_node_usage_stats_bio(const struct lhash_st_OPENSSL_STRING *lh, BIO *out) { OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_OPENSSL_STRING_stats_bio(const struct lhash_st_OPENSSL_STRING *lh, BIO *out) { OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline unsigned long lh_OPENSSL_STRING_get_down_load(struct lhash_st_OPENSSL_STRING *lh) { return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); } static inline void lh_OPENSSL_STRING_set_down_load(struct lhash_st_OPENSSL_STRING *lh, unsigned long dl) { OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); } static inline void lh_OPENSSL_STRING_doall(struct lhash_st_OPENSSL_STRING *lh, void (*doall)(OPENSSL_STRING *)) { OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); } struct lhash_st_OPENSSL_STRING;
># 207 "/usr/include/openssl/lhash.h" 3 4
>struct lhash_st_OPENSSL_CSTRING { union lh_OPENSSL_CSTRING_dummy { void* d1; unsigned long d2; int d3; } dummy; }; static inline struct lhash_st_OPENSSL_CSTRING * lh_OPENSSL_CSTRING_new(unsigned long (*hfn)(const OPENSSL_CSTRING *), int (*cfn)(const OPENSSL_CSTRING *, const OPENSSL_CSTRING *)) { return (struct lhash_st_OPENSSL_CSTRING *) OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); } static inline void lh_OPENSSL_CSTRING_free(struct lhash_st_OPENSSL_CSTRING *lh) { OPENSSL_LH_free((OPENSSL_LHASH *)lh); } static inline OPENSSL_CSTRING *lh_OPENSSL_CSTRING_insert(struct lhash_st_OPENSSL_CSTRING *lh, OPENSSL_CSTRING *d) { return (OPENSSL_CSTRING *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); } static inline OPENSSL_CSTRING *lh_OPENSSL_CSTRING_delete(struct lhash_st_OPENSSL_CSTRING *lh, const OPENSSL_CSTRING *d) { return (OPENSSL_CSTRING *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); } static inline OPENSSL_CSTRING *lh_OPENSSL_CSTRING_retrieve(struct lhash_st_OPENSSL_CSTRING *lh, const OPENSSL_CSTRING *d) { return (OPENSSL_CSTRING *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); } static inline int lh_OPENSSL_CSTRING_error(struct lhash_st_OPENSSL_CSTRING *lh) { return OPENSSL_LH_error((OPENSSL_LHASH *)lh); } static inline unsigned long lh_OPENSSL_CSTRING_num_items(struct lhash_st_OPENSSL_CSTRING *lh) { return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); } static inline void lh_OPENSSL_CSTRING_node_stats_bio(const struct lhash_st_OPENSSL_CSTRING *lh, BIO *out) { OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_OPENSSL_CSTRING_node_usage_stats_bio(const struct lhash_st_OPENSSL_CSTRING *lh, BIO *out) { OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_OPENSSL_CSTRING_stats_bio(const struct lhash_st_OPENSSL_CSTRING *lh, BIO *out) { OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline unsigned long lh_OPENSSL_CSTRING_get_down_load(struct lhash_st_OPENSSL_CSTRING *lh) { return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); } static inline void lh_OPENSSL_CSTRING_set_down_load(struct lhash_st_OPENSSL_CSTRING *lh, unsigned long dl) { OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); } static inline void lh_OPENSSL_CSTRING_doall(struct lhash_st_OPENSSL_CSTRING *lh, void (*doall)(OPENSSL_CSTRING *)) { OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); } struct lhash_st_OPENSSL_CSTRING;
>
>
>
>
>
>
>}
># 15 "/usr/include/openssl/conf.h" 2 3 4
>
>
>
>
>
>
>
>extern "C" {
>
>
>typedef struct {
> char *section;
> char *name;
> char *value;
>} CONF_VALUE;
>
>struct stack_st_CONF_VALUE; typedef int (*sk_CONF_VALUE_compfunc)(const CONF_VALUE * const *a, const CONF_VALUE *const *b); typedef void (*sk_CONF_VALUE_freefunc)(CONF_VALUE *a); typedef CONF_VALUE * (*sk_CONF_VALUE_copyfunc)(const CONF_VALUE *a); static inline int sk_CONF_VALUE_num(const struct stack_st_CONF_VALUE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline CONF_VALUE *sk_CONF_VALUE_value(const struct stack_st_CONF_VALUE *sk, int idx) { return (CONF_VALUE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_CONF_VALUE *sk_CONF_VALUE_new(sk_CONF_VALUE_compfunc compare) { return (struct stack_st_CONF_VALUE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_CONF_VALUE *sk_CONF_VALUE_new_null(void) { return (struct stack_st_CONF_VALUE *)OPENSSL_sk_new_null(); } static inline void sk_CONF_VALUE_free(struct stack_st_CONF_VALUE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_CONF_VALUE_zero(struct stack_st_CONF_VALUE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline CONF_VALUE *sk_CONF_VALUE_delete(struct stack_st_CONF_VALUE *sk, int i) { return (CONF_VALUE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline CONF_VALUE *sk_CONF_VALUE_delete_ptr(struct stack_st_CONF_VALUE *sk, CONF_VALUE *ptr) { return (CONF_VALUE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_VALUE_push(struct stack_st_CONF_VALUE *sk, CONF_VALUE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_VALUE_unshift(struct stack_st_CONF_VALUE *sk, CONF_VALUE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline CONF_VALUE *sk_CONF_VALUE_pop(struct stack_st_CONF_VALUE *sk) { return (CONF_VALUE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline CONF_VALUE *sk_CONF_VALUE_shift(struct stack_st_CONF_VALUE *sk) { return (CONF_VALUE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_CONF_VALUE_pop_free(struct stack_st_CONF_VALUE *sk, sk_CONF_VALUE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_CONF_VALUE_insert(struct stack_st_CONF_VALUE *sk, CONF_VALUE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline CONF_VALUE *sk_CONF_VALUE_set(struct stack_st_CONF_VALUE *sk, int idx, CONF_VALUE *ptr) { return (CONF_VALUE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_CONF_VALUE_find(struct stack_st_CONF_VALUE *sk, CONF_VALUE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_VALUE_find_ex(struct stack_st_CONF_VALUE *sk, CONF_VALUE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_CONF_VALUE_sort(struct stack_st_CONF_VALUE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_CONF_VALUE_is_sorted(const struct stack_st_CONF_VALUE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_CONF_VALUE * sk_CONF_VALUE_dup(const struct stack_st_CONF_VALUE *sk) { return (struct stack_st_CONF_VALUE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_CONF_VALUE *sk_CONF_VALUE_deep_copy(const struct stack_st_CONF_VALUE *sk, sk_CONF_VALUE_copyfunc copyfunc, sk_CONF_VALUE_freefunc freefunc) { return (struct stack_st_CONF_VALUE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_CONF_VALUE_compfunc sk_CONF_VALUE_set_cmp_func(struct stack_st_CONF_VALUE *sk, sk_CONF_VALUE_compfunc compare) { return (sk_CONF_VALUE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct lhash_st_CONF_VALUE { union lh_CONF_VALUE_dummy { void* d1; unsigned long d2; int d3; } dummy; }; static inline struct lhash_st_CONF_VALUE * lh_CONF_VALUE_new(unsigned long (*hfn)(const CONF_VALUE *), int (*cfn)(const CONF_VALUE *, const CONF_VALUE *)) { return (struct lhash_st_CONF_VALUE *) OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); } static inline void lh_CONF_VALUE_free(struct lhash_st_CONF_VALUE *lh) { OPENSSL_LH_free((OPENSSL_LHASH *)lh); } static inline CONF_VALUE *lh_CONF_VALUE_insert(struct lhash_st_CONF_VALUE *lh, CONF_VALUE *d) { return (CONF_VALUE *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); } static inline CONF_VALUE *lh_CONF_VALUE_delete(struct lhash_st_CONF_VALUE *lh, const CONF_VALUE *d) { return (CONF_VALUE *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); } static inline CONF_VALUE *lh_CONF_VALUE_retrieve(struct lhash_st_CONF_VALUE *lh, const CONF_VALUE *d) { return (CONF_VALUE *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); } static inline int lh_CONF_VALUE_error(struct lhash_st_CONF_VALUE *lh) { return OPENSSL_LH_error((OPENSSL_LHASH *)lh); } static inline unsigned long lh_CONF_VALUE_num_items(struct lhash_st_CONF_VALUE *lh) { return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); } static inline void lh_CONF_VALUE_node_stats_bio(const struct lhash_st_CONF_VALUE *lh, BIO *out) { OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_CONF_VALUE_node_usage_stats_bio(const struct lhash_st_CONF_VALUE *lh, BIO *out) { OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_CONF_VALUE_stats_bio(const struct lhash_st_CONF_VALUE *lh, BIO *out) { OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline unsigned long lh_CONF_VALUE_get_down_load(struct lhash_st_CONF_VALUE *lh) { return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); } static inline void lh_CONF_VALUE_set_down_load(struct lhash_st_CONF_VALUE *lh, unsigned long dl) { OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); } static inline void lh_CONF_VALUE_doall(struct lhash_st_CONF_VALUE *lh, void (*doall)(CONF_VALUE *)) { OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); } struct lhash_st_CONF_VALUE;
>
>struct conf_st;
>struct conf_method_st;
>typedef struct conf_method_st CONF_METHOD;
>
>struct conf_method_st {
> const char *name;
> CONF *(*create) (CONF_METHOD *meth);
> int (*init) (CONF *conf);
> int (*destroy) (CONF *conf);
> int (*destroy_data) (CONF *conf);
> int (*load_bio) (CONF *conf, BIO *bp, long *eline);
> int (*dump) (const CONF *conf, BIO *bp);
> int (*is_number) (const CONF *conf, char c);
> int (*to_int) (const CONF *conf, char c);
> int (*load) (CONF *conf, const char *name, long *eline);
>};
>
>
>
>typedef struct conf_imodule_st CONF_IMODULE;
>typedef struct conf_module_st CONF_MODULE;
>
>struct stack_st_CONF_MODULE; typedef int (*sk_CONF_MODULE_compfunc)(const CONF_MODULE * const *a, const CONF_MODULE *const *b); typedef void (*sk_CONF_MODULE_freefunc)(CONF_MODULE *a); typedef CONF_MODULE * (*sk_CONF_MODULE_copyfunc)(const CONF_MODULE *a); static inline int sk_CONF_MODULE_num(const struct stack_st_CONF_MODULE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline CONF_MODULE *sk_CONF_MODULE_value(const struct stack_st_CONF_MODULE *sk, int idx) { return (CONF_MODULE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_CONF_MODULE *sk_CONF_MODULE_new(sk_CONF_MODULE_compfunc compare) { return (struct stack_st_CONF_MODULE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_CONF_MODULE *sk_CONF_MODULE_new_null(void) { return (struct stack_st_CONF_MODULE *)OPENSSL_sk_new_null(); } static inline void sk_CONF_MODULE_free(struct stack_st_CONF_MODULE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_CONF_MODULE_zero(struct stack_st_CONF_MODULE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline CONF_MODULE *sk_CONF_MODULE_delete(struct stack_st_CONF_MODULE *sk, int i) { return (CONF_MODULE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline CONF_MODULE *sk_CONF_MODULE_delete_ptr(struct stack_st_CONF_MODULE *sk, CONF_MODULE *ptr) { return (CONF_MODULE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_MODULE_push(struct stack_st_CONF_MODULE *sk, CONF_MODULE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_MODULE_unshift(struct stack_st_CONF_MODULE *sk, CONF_MODULE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline CONF_MODULE *sk_CONF_MODULE_pop(struct stack_st_CONF_MODULE *sk) { return (CONF_MODULE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline CONF_MODULE *sk_CONF_MODULE_shift(struct stack_st_CONF_MODULE *sk) { return (CONF_MODULE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_CONF_MODULE_pop_free(struct stack_st_CONF_MODULE *sk, sk_CONF_MODULE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_CONF_MODULE_insert(struct stack_st_CONF_MODULE *sk, CONF_MODULE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline CONF_MODULE *sk_CONF_MODULE_set(struct stack_st_CONF_MODULE *sk, int idx, CONF_MODULE *ptr) { return (CONF_MODULE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_CONF_MODULE_find(struct stack_st_CONF_MODULE *sk, CONF_MODULE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_MODULE_find_ex(struct stack_st_CONF_MODULE *sk, CONF_MODULE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_CONF_MODULE_sort(struct stack_st_CONF_MODULE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_CONF_MODULE_is_sorted(const struct stack_st_CONF_MODULE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_CONF_MODULE * sk_CONF_MODULE_dup(const struct stack_st_CONF_MODULE *sk) { return (struct stack_st_CONF_MODULE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_CONF_MODULE *sk_CONF_MODULE_deep_copy(const struct stack_st_CONF_MODULE *sk, sk_CONF_MODULE_copyfunc copyfunc, sk_CONF_MODULE_freefunc freefunc) { return (struct stack_st_CONF_MODULE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_CONF_MODULE_compfunc sk_CONF_MODULE_set_cmp_func(struct stack_st_CONF_MODULE *sk, sk_CONF_MODULE_compfunc compare) { return (sk_CONF_MODULE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct stack_st_CONF_IMODULE; typedef int (*sk_CONF_IMODULE_compfunc)(const CONF_IMODULE * const *a, const CONF_IMODULE *const *b); typedef void (*sk_CONF_IMODULE_freefunc)(CONF_IMODULE *a); typedef CONF_IMODULE * (*sk_CONF_IMODULE_copyfunc)(const CONF_IMODULE *a); static inline int sk_CONF_IMODULE_num(const struct stack_st_CONF_IMODULE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline CONF_IMODULE *sk_CONF_IMODULE_value(const struct stack_st_CONF_IMODULE *sk, int idx) { return (CONF_IMODULE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_CONF_IMODULE *sk_CONF_IMODULE_new(sk_CONF_IMODULE_compfunc compare) { return (struct stack_st_CONF_IMODULE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_CONF_IMODULE *sk_CONF_IMODULE_new_null(void) { return (struct stack_st_CONF_IMODULE *)OPENSSL_sk_new_null(); } static inline void sk_CONF_IMODULE_free(struct stack_st_CONF_IMODULE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_CONF_IMODULE_zero(struct stack_st_CONF_IMODULE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline CONF_IMODULE *sk_CONF_IMODULE_delete(struct stack_st_CONF_IMODULE *sk, int i) { return (CONF_IMODULE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline CONF_IMODULE *sk_CONF_IMODULE_delete_ptr(struct stack_st_CONF_IMODULE *sk, CONF_IMODULE *ptr) { return (CONF_IMODULE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_IMODULE_push(struct stack_st_CONF_IMODULE *sk, CONF_IMODULE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_IMODULE_unshift(struct stack_st_CONF_IMODULE *sk, CONF_IMODULE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline CONF_IMODULE *sk_CONF_IMODULE_pop(struct stack_st_CONF_IMODULE *sk) { return (CONF_IMODULE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline CONF_IMODULE *sk_CONF_IMODULE_shift(struct stack_st_CONF_IMODULE *sk) { return (CONF_IMODULE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_CONF_IMODULE_pop_free(struct stack_st_CONF_IMODULE *sk, sk_CONF_IMODULE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_CONF_IMODULE_insert(struct stack_st_CONF_IMODULE *sk, CONF_IMODULE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline CONF_IMODULE *sk_CONF_IMODULE_set(struct stack_st_CONF_IMODULE *sk, int idx, CONF_IMODULE *ptr) { return (CONF_IMODULE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_CONF_IMODULE_find(struct stack_st_CONF_IMODULE *sk, CONF_IMODULE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CONF_IMODULE_find_ex(struct stack_st_CONF_IMODULE *sk, CONF_IMODULE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_CONF_IMODULE_sort(struct stack_st_CONF_IMODULE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_CONF_IMODULE_is_sorted(const struct stack_st_CONF_IMODULE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_CONF_IMODULE * sk_CONF_IMODULE_dup(const struct stack_st_CONF_IMODULE *sk) { return (struct stack_st_CONF_IMODULE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_CONF_IMODULE *sk_CONF_IMODULE_deep_copy(const struct stack_st_CONF_IMODULE *sk, sk_CONF_IMODULE_copyfunc copyfunc, sk_CONF_IMODULE_freefunc freefunc) { return (struct stack_st_CONF_IMODULE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_CONF_IMODULE_compfunc sk_CONF_IMODULE_set_cmp_func(struct stack_st_CONF_IMODULE *sk, sk_CONF_IMODULE_compfunc compare) { return (sk_CONF_IMODULE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf);
>typedef void conf_finish_func (CONF_IMODULE *md);
># 70 "/usr/include/openssl/conf.h" 3 4
>int CONF_set_default_method(CONF_METHOD *meth);
>void CONF_set_nconf(CONF *conf, struct lhash_st_CONF_VALUE *hash);
>struct lhash_st_CONF_VALUE *CONF_load(struct lhash_st_CONF_VALUE *conf, const char *file,
> long *eline);
>
>struct lhash_st_CONF_VALUE *CONF_load_fp(struct lhash_st_CONF_VALUE *conf, FILE *fp,
> long *eline);
>
>struct lhash_st_CONF_VALUE *CONF_load_bio(struct lhash_st_CONF_VALUE *conf, BIO *bp,
> long *eline);
>struct stack_st_CONF_VALUE *CONF_get_section(struct lhash_st_CONF_VALUE *conf,
> const char *section);
>char *CONF_get_string(struct lhash_st_CONF_VALUE *conf, const char *group,
> const char *name);
>long CONF_get_number(struct lhash_st_CONF_VALUE *conf, const char *group,
> const char *name);
>void CONF_free(struct lhash_st_CONF_VALUE *conf);
>
>int CONF_dump_fp(struct lhash_st_CONF_VALUE *conf, FILE *out);
>
>int CONF_dump_bio(struct lhash_st_CONF_VALUE *conf, BIO *out);
>
>void OPENSSL_config(const char *config_name) __attribute__ ((deprecated));
># 104 "/usr/include/openssl/conf.h" 3 4
>struct conf_st {
> CONF_METHOD *meth;
> void *meth_data;
> struct lhash_st_CONF_VALUE *data;
>};
>
>CONF *NCONF_new(CONF_METHOD *meth);
>CONF_METHOD *NCONF_default(void);
>CONF_METHOD *NCONF_WIN32(void);
>void NCONF_free(CONF *conf);
>void NCONF_free_data(CONF *conf);
>
>int NCONF_load(CONF *conf, const char *file, long *eline);
>
>int NCONF_load_fp(CONF *conf, FILE *fp, long *eline);
>
>int NCONF_load_bio(CONF *conf, BIO *bp, long *eline);
>struct stack_st_CONF_VALUE *NCONF_get_section(const CONF *conf,
> const char *section);
>char *NCONF_get_string(const CONF *conf, const char *group, const char *name);
>int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
> long *result);
>
>int NCONF_dump_fp(const CONF *conf, FILE *out);
>
>int NCONF_dump_bio(const CONF *conf, BIO *out);
>
>
>
>
>
>int CONF_modules_load(const CONF *cnf, const char *appname,
> unsigned long flags);
>int CONF_modules_load_file(const char *filename, const char *appname,
> unsigned long flags);
>void CONF_modules_unload(int all);
>void CONF_modules_finish(void);
>
>
>
>int CONF_module_add(const char *name, conf_init_func *ifunc,
> conf_finish_func *ffunc);
>
>const char *CONF_imodule_get_name(const CONF_IMODULE *md);
>const char *CONF_imodule_get_value(const CONF_IMODULE *md);
>void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
>void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
>CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
>unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
>void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
>void *CONF_module_get_usr_data(CONF_MODULE *pmod);
>void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
>
>char *CONF_get1_default_config_file(void);
>
>int CONF_parse_list(const char *list, int sep, int nospc,
> int (*list_cb) (const char *elem, int len, void *usr),
> void *arg);
>
>void OPENSSL_load_builtin_modules(void);
>
>
>
>
>
>
>
>int ERR_load_CONF_strings(void);
># 215 "/usr/include/openssl/conf.h" 3 4
>}
># 21 "/usr/include/boost/asio/ssl/detail/openssl_types.hpp" 2 3 4
># 1 "/usr/include/openssl/ssl.h" 1 3 4
># 46 "/usr/include/openssl/ssl.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 47 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/comp.h" 1 3 4
># 13 "/usr/include/openssl/comp.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/comp.h" 2 3 4
>
>
>
>
>extern "C" {
>
>
>
>
>COMP_CTX *COMP_CTX_new(COMP_METHOD *meth);
>const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx);
>int COMP_CTX_get_type(const COMP_CTX* comp);
>int COMP_get_type(const COMP_METHOD *meth);
>const char *COMP_get_name(const COMP_METHOD *meth);
>void COMP_CTX_free(COMP_CTX *ctx);
>
>int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen,
> unsigned char *in, int ilen);
>int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen,
> unsigned char *in, int ilen);
>
>COMP_METHOD *COMP_zlib(void);
># 53 "/usr/include/openssl/comp.h" 3 4
>int ERR_load_COMP_strings(void);
># 69 "/usr/include/openssl/comp.h" 3 4
>}
># 48 "/usr/include/openssl/ssl.h" 2 3 4
>
>
># 1 "/usr/include/openssl/x509.h" 1 3 4
># 22 "/usr/include/openssl/x509.h" 3 4
># 1 "/usr/include/openssl/buffer.h" 1 3 4
># 20 "/usr/include/openssl/buffer.h" 3 4
>extern "C" {
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 24 "/usr/include/openssl/buffer.h" 2 3 4
># 37 "/usr/include/openssl/buffer.h" 3 4
>struct buf_mem_st {
> size_t length;
> char *data;
> size_t max;
> unsigned long flags;
>};
>
>
>
>BUF_MEM *BUF_MEM_new(void);
>BUF_MEM *BUF_MEM_new_ex(unsigned long flags);
>void BUF_MEM_free(BUF_MEM *a);
>size_t BUF_MEM_grow(BUF_MEM *str, size_t len);
>size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len);
>void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz);
>
>
>
>
>
>
>
>int ERR_load_BUF_strings(void);
># 71 "/usr/include/openssl/buffer.h" 3 4
>}
># 23 "/usr/include/openssl/x509.h" 2 3 4
># 1 "/usr/include/openssl/evp.h" 1 3 4
># 13 "/usr/include/openssl/evp.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/evp.h" 2 3 4
># 27 "/usr/include/openssl/evp.h" 3 4
># 1 "/usr/include/openssl/objects.h" 1 3 4
># 16 "/usr/include/openssl/objects.h" 3 4
># 1 "/usr/include/openssl/obj_mac.h" 1 3 4
># 17 "/usr/include/openssl/objects.h" 2 3 4
># 916 "/usr/include/openssl/objects.h" 3 4
># 1 "/usr/include/openssl/asn1.h" 1 3 4
># 15 "/usr/include/openssl/asn1.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 16 "/usr/include/openssl/asn1.h" 2 3 4
># 24 "/usr/include/openssl/asn1.h" 3 4
># 1 "/usr/include/openssl/bn.h" 1 3 4
># 31 "/usr/include/openssl/bn.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 32 "/usr/include/openssl/bn.h" 2 3 4
>
>
>
>
>extern "C" {
># 82 "/usr/include/openssl/bn.h" 3 4
>void BN_set_flags(BIGNUM *b, int n);
>int BN_get_flags(const BIGNUM *b, int n);
># 100 "/usr/include/openssl/bn.h" 3 4
>void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags);
>
>
>int BN_GENCB_call(BN_GENCB *cb, int a, int b);
>
>BN_GENCB *BN_GENCB_new(void);
>void BN_GENCB_free(BN_GENCB *cb);
>
>
>void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *),
> void *cb_arg);
>
>
>void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *),
> void *cb_arg);
>
>void *BN_GENCB_get_arg(BN_GENCB *cb);
># 144 "/usr/include/openssl/bn.h" 3 4
>int BN_abs_is_word(const BIGNUM *a, const unsigned long w);
>int BN_is_zero(const BIGNUM *a);
>int BN_is_one(const BIGNUM *a);
>int BN_is_word(const BIGNUM *a, const unsigned long w);
>int BN_is_odd(const BIGNUM *a);
>
>
>
>void BN_zero_ex(BIGNUM *a);
>
>
>
>
>
>
>
>const BIGNUM *BN_value_one(void);
>char *BN_options(void);
>BN_CTX *BN_CTX_new(void);
>BN_CTX *BN_CTX_secure_new(void);
>void BN_CTX_free(BN_CTX *c);
>void BN_CTX_start(BN_CTX *ctx);
>BIGNUM *BN_CTX_get(BN_CTX *ctx);
>void BN_CTX_end(BN_CTX *ctx);
>int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
>int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
>int BN_rand_range(BIGNUM *rnd, const BIGNUM *range);
>int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range);
>int BN_num_bits(const BIGNUM *a);
>int BN_num_bits_word(unsigned long l);
>int BN_security_bits(int L, int N);
>BIGNUM *BN_new(void);
>BIGNUM *BN_secure_new(void);
>void BN_clear_free(BIGNUM *a);
>BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b);
>void BN_swap(BIGNUM *a, BIGNUM *b);
>BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret);
>int BN_bn2bin(const BIGNUM *a, unsigned char *to);
>int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen);
>BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret);
>int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen);
>BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret);
>int BN_bn2mpi(const BIGNUM *a, unsigned char *to);
>int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
>int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
>int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
>int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
>int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
>int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx);
>
>
>
>
>void BN_set_negative(BIGNUM *b, int n);
>
>
>
>
>int BN_is_negative(const BIGNUM *b);
>
>int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
> BN_CTX *ctx);
>
>int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx);
>int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
> BN_CTX *ctx);
>int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
> const BIGNUM *m);
>int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
> BN_CTX *ctx);
>int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
> const BIGNUM *m);
>int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m,
> BN_CTX *ctx);
>int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
>int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx);
>int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m);
>int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
> BN_CTX *ctx);
>int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m);
>
>unsigned long BN_mod_word(const BIGNUM *a, unsigned long w);
>unsigned long BN_div_word(BIGNUM *a, unsigned long w);
>int BN_mul_word(BIGNUM *a, unsigned long w);
>int BN_add_word(BIGNUM *a, unsigned long w);
>int BN_sub_word(BIGNUM *a, unsigned long w);
>int BN_set_word(BIGNUM *a, unsigned long w);
>unsigned long BN_get_word(const BIGNUM *a);
>
>int BN_cmp(const BIGNUM *a, const BIGNUM *b);
>void BN_free(BIGNUM *a);
>int BN_is_bit_set(const BIGNUM *a, int n);
>int BN_lshift(BIGNUM *r, const BIGNUM *a, int n);
>int BN_lshift1(BIGNUM *r, const BIGNUM *a);
>int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
>
>int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx);
>int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
>int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx,
> BN_MONT_CTX *in_mont);
>int BN_mod_exp_mont_word(BIGNUM *r, unsigned long a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
>int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1,
> const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m,
> BN_CTX *ctx, BN_MONT_CTX *m_ctx);
>int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx);
>
>int BN_mask_bits(BIGNUM *a, int n);
>
>int BN_print_fp(FILE *fp, const BIGNUM *a);
>
>int BN_print(BIO *bio, const BIGNUM *a);
>int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
>int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
>int BN_rshift1(BIGNUM *r, const BIGNUM *a);
>void BN_clear(BIGNUM *a);
>BIGNUM *BN_dup(const BIGNUM *a);
>int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
>int BN_set_bit(BIGNUM *a, int n);
>int BN_clear_bit(BIGNUM *a, int n);
>char *BN_bn2hex(const BIGNUM *a);
>char *BN_bn2dec(const BIGNUM *a);
>int BN_hex2bn(BIGNUM **a, const char *str);
>int BN_dec2bn(BIGNUM **a, const char *str);
>int BN_asc2bn(BIGNUM **a, const char *str);
>int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
>int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
>
>
>BIGNUM *BN_mod_inverse(BIGNUM *ret,
> const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
>BIGNUM *BN_mod_sqrt(BIGNUM *ret,
> const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
>
>void BN_consttime_swap(unsigned long swap, BIGNUM *a, BIGNUM *b, int nwords);
>
>
>BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, const BIGNUM *add, const BIGNUM *rem, void (*callback) (int, int, void *), void *cb_arg) __attribute__ ((deprecated));
>
>
>
>
>
>int BN_is_prime(const BIGNUM *p, int nchecks, void (*callback) (int, int, void *), BN_CTX *ctx, void *cb_arg) __attribute__ ((deprecated));
>
>
>
>int BN_is_prime_fasttest(const BIGNUM *p, int nchecks, void (*callback) (int, int, void *), BN_CTX *ctx, void *cb_arg, int do_trial_division) __attribute__ ((deprecated));
>
>
>
>
>
>
>int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add,
> const BIGNUM *rem, BN_GENCB *cb);
>int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb);
>int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx,
> int do_trial_division, BN_GENCB *cb);
>
>int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx);
>
>int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2,
> const BIGNUM *Xp, const BIGNUM *Xp1,
> const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx,
> BN_GENCB *cb);
>int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1,
> BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e,
> BN_CTX *ctx, BN_GENCB *cb);
>
>BN_MONT_CTX *BN_MONT_CTX_new(void);
>int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
> BN_MONT_CTX *mont, BN_CTX *ctx);
>int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
> BN_CTX *ctx);
>int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,
> BN_CTX *ctx);
>void BN_MONT_CTX_free(BN_MONT_CTX *mont);
>int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx);
>BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from);
>BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock,
> const BIGNUM *mod, BN_CTX *ctx);
>
>
>
>
>
>BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod);
>void BN_BLINDING_free(BN_BLINDING *b);
>int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx);
>int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
>int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx);
>int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *);
>int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
> BN_CTX *);
>
>int BN_BLINDING_is_current_thread(BN_BLINDING *b);
>void BN_BLINDING_set_current_thread(BN_BLINDING *b);
>int BN_BLINDING_lock(BN_BLINDING *b);
>int BN_BLINDING_unlock(BN_BLINDING *b);
>
>unsigned long BN_BLINDING_get_flags(const BN_BLINDING *);
>void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long);
>BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
> const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
> int (*bn_mod_exp) (BIGNUM *r,
> const BIGNUM *a,
> const BIGNUM *p,
> const BIGNUM *m,
> BN_CTX *ctx,
> BN_MONT_CTX *m_ctx),
> BN_MONT_CTX *m_ctx);
>
>void BN_set_params(int mul, int high, int low, int mont) __attribute__ ((deprecated));
>int BN_get_params(int which) __attribute__ ((deprecated));
>
>
>BN_RECP_CTX *BN_RECP_CTX_new(void);
>void BN_RECP_CTX_free(BN_RECP_CTX *recp);
>int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx);
>int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y,
> BN_RECP_CTX *recp, BN_CTX *ctx);
>int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx);
>int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m,
> BN_RECP_CTX *recp, BN_CTX *ctx);
># 450 "/usr/include/openssl/bn.h" 3 4
>int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
>int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
>int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
>int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
>int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx);
>
>const BIGNUM *BN_get0_nist_prime_192(void);
>const BIGNUM *BN_get0_nist_prime_224(void);
>const BIGNUM *BN_get0_nist_prime_256(void);
>const BIGNUM *BN_get0_nist_prime_384(void);
>const BIGNUM *BN_get0_nist_prime_521(void);
>
>int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a,
> const BIGNUM *field, BN_CTX *ctx);
>
>int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
> const BIGNUM *priv, const unsigned char *message,
> size_t message_len, BN_CTX *ctx);
>
>
>BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn);
>BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn);
>
>
>BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn);
>BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn);
>BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn);
>BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn);
>BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn);
>BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn);
># 492 "/usr/include/openssl/bn.h" 3 4
>int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom);
>
>
>
>
>
>
>
>int ERR_load_BN_strings(void);
># 573 "/usr/include/openssl/bn.h" 3 4
>}
># 25 "/usr/include/openssl/asn1.h" 2 3 4
># 33 "/usr/include/openssl/asn1.h" 3 4
>extern "C" {
># 119 "/usr/include/openssl/asn1.h" 3 4
> struct X509_algor_st;
>struct stack_st_X509_ALGOR; typedef int (*sk_X509_ALGOR_compfunc)(const X509_ALGOR * const *a, const X509_ALGOR *const *b); typedef void (*sk_X509_ALGOR_freefunc)(X509_ALGOR *a); typedef X509_ALGOR * (*sk_X509_ALGOR_copyfunc)(const X509_ALGOR *a); static inline int sk_X509_ALGOR_num(const struct stack_st_X509_ALGOR *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_ALGOR *sk_X509_ALGOR_value(const struct stack_st_X509_ALGOR *sk, int idx) { return (X509_ALGOR *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_new(sk_X509_ALGOR_compfunc compare) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_new_null(void) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_new_null(); } static inline void sk_X509_ALGOR_free(struct stack_st_X509_ALGOR *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_ALGOR_zero(struct stack_st_X509_ALGOR *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_ALGOR *sk_X509_ALGOR_delete(struct stack_st_X509_ALGOR *sk, int i) { return (X509_ALGOR *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_ALGOR *sk_X509_ALGOR_delete_ptr(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return (X509_ALGOR *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_ALGOR_push(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_ALGOR_unshift(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_ALGOR *sk_X509_ALGOR_pop(struct stack_st_X509_ALGOR *sk) { return (X509_ALGOR *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_ALGOR *sk_X509_ALGOR_shift(struct stack_st_X509_ALGOR *sk) { return (X509_ALGOR *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_ALGOR_pop_free(struct stack_st_X509_ALGOR *sk, sk_X509_ALGOR_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_ALGOR_insert(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_ALGOR *sk_X509_ALGOR_set(struct stack_st_X509_ALGOR *sk, int idx, X509_ALGOR *ptr) { return (X509_ALGOR *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_ALGOR_find(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_ALGOR_find_ex(struct stack_st_X509_ALGOR *sk, X509_ALGOR *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_ALGOR_sort(struct stack_st_X509_ALGOR *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_ALGOR_is_sorted(const struct stack_st_X509_ALGOR *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_ALGOR * sk_X509_ALGOR_dup(const struct stack_st_X509_ALGOR *sk) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_ALGOR *sk_X509_ALGOR_deep_copy(const struct stack_st_X509_ALGOR *sk, sk_X509_ALGOR_copyfunc copyfunc, sk_X509_ALGOR_freefunc freefunc) { return (struct stack_st_X509_ALGOR *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_ALGOR_compfunc sk_X509_ALGOR_set_cmp_func(struct stack_st_X509_ALGOR *sk, sk_X509_ALGOR_compfunc compare) { return (sk_X509_ALGOR_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 145 "/usr/include/openssl/asn1.h" 3 4
>struct asn1_string_st {
> int length;
> int type;
> unsigned char *data;
>
>
>
>
>
> long flags;
>};
>
>
>
>
>
>
>
>typedef struct ASN1_ENCODING_st {
> unsigned char *enc;
> long len;
> int modified;
>} ASN1_ENCODING;
># 185 "/usr/include/openssl/asn1.h" 3 4
>typedef struct asn1_string_table_st {
> int nid;
> long minsize;
> long maxsize;
> unsigned long mask;
> unsigned long flags;
>} ASN1_STRING_TABLE;
>
>struct stack_st_ASN1_STRING_TABLE; typedef int (*sk_ASN1_STRING_TABLE_compfunc)(const ASN1_STRING_TABLE * const *a, const ASN1_STRING_TABLE *const *b); typedef void (*sk_ASN1_STRING_TABLE_freefunc)(ASN1_STRING_TABLE *a); typedef ASN1_STRING_TABLE * (*sk_ASN1_STRING_TABLE_copyfunc)(const ASN1_STRING_TABLE *a); static inline int sk_ASN1_STRING_TABLE_num(const struct stack_st_ASN1_STRING_TABLE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_value(const struct stack_st_ASN1_STRING_TABLE *sk, int idx) { return (ASN1_STRING_TABLE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_new(sk_ASN1_STRING_TABLE_compfunc compare) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_new_null(void) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_new_null(); } static inline void sk_ASN1_STRING_TABLE_free(struct stack_st_ASN1_STRING_TABLE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASN1_STRING_TABLE_zero(struct stack_st_ASN1_STRING_TABLE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_delete(struct stack_st_ASN1_STRING_TABLE *sk, int i) { return (ASN1_STRING_TABLE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_delete_ptr(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return (ASN1_STRING_TABLE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_STRING_TABLE_push(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_STRING_TABLE_unshift(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_pop(struct stack_st_ASN1_STRING_TABLE *sk) { return (ASN1_STRING_TABLE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_shift(struct stack_st_ASN1_STRING_TABLE *sk) { return (ASN1_STRING_TABLE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASN1_STRING_TABLE_pop_free(struct stack_st_ASN1_STRING_TABLE *sk, sk_ASN1_STRING_TABLE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASN1_STRING_TABLE_insert(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_set(struct stack_st_ASN1_STRING_TABLE *sk, int idx, ASN1_STRING_TABLE *ptr) { return (ASN1_STRING_TABLE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASN1_STRING_TABLE_find(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_STRING_TABLE_find_ex(struct stack_st_ASN1_STRING_TABLE *sk, ASN1_STRING_TABLE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASN1_STRING_TABLE_sort(struct stack_st_ASN1_STRING_TABLE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASN1_STRING_TABLE_is_sorted(const struct stack_st_ASN1_STRING_TABLE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_STRING_TABLE * sk_ASN1_STRING_TABLE_dup(const struct stack_st_ASN1_STRING_TABLE *sk) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_STRING_TABLE *sk_ASN1_STRING_TABLE_deep_copy(const struct stack_st_ASN1_STRING_TABLE *sk, sk_ASN1_STRING_TABLE_copyfunc copyfunc, sk_ASN1_STRING_TABLE_freefunc freefunc) { return (struct stack_st_ASN1_STRING_TABLE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASN1_STRING_TABLE_compfunc sk_ASN1_STRING_TABLE_set_cmp_func(struct stack_st_ASN1_STRING_TABLE *sk, sk_ASN1_STRING_TABLE_compfunc compare) { return (sk_ASN1_STRING_TABLE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 209 "/usr/include/openssl/asn1.h" 3 4
>typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE;
>typedef struct ASN1_TLC_st ASN1_TLC;
>
>typedef struct ASN1_VALUE_st ASN1_VALUE;
># 276 "/usr/include/openssl/asn1.h" 3 4
>typedef void *d2i_of_void(void **,const unsigned char **,long); typedef int i2d_of_void(void *,unsigned char **);
># 317 "/usr/include/openssl/asn1.h" 3 4
>typedef const ASN1_ITEM ASN1_ITEM_EXP;
># 437 "/usr/include/openssl/asn1.h" 3 4
>struct stack_st_ASN1_INTEGER; typedef int (*sk_ASN1_INTEGER_compfunc)(const ASN1_INTEGER * const *a, const ASN1_INTEGER *const *b); typedef void (*sk_ASN1_INTEGER_freefunc)(ASN1_INTEGER *a); typedef ASN1_INTEGER * (*sk_ASN1_INTEGER_copyfunc)(const ASN1_INTEGER *a); static inline int sk_ASN1_INTEGER_num(const struct stack_st_ASN1_INTEGER *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASN1_INTEGER *sk_ASN1_INTEGER_value(const struct stack_st_ASN1_INTEGER *sk, int idx) { return (ASN1_INTEGER *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_new(sk_ASN1_INTEGER_compfunc compare) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_new_null(void) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_new_null(); } static inline void sk_ASN1_INTEGER_free(struct stack_st_ASN1_INTEGER *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASN1_INTEGER_zero(struct stack_st_ASN1_INTEGER *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASN1_INTEGER *sk_ASN1_INTEGER_delete(struct stack_st_ASN1_INTEGER *sk, int i) { return (ASN1_INTEGER *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASN1_INTEGER *sk_ASN1_INTEGER_delete_ptr(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return (ASN1_INTEGER *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_INTEGER_push(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_INTEGER_unshift(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASN1_INTEGER *sk_ASN1_INTEGER_pop(struct stack_st_ASN1_INTEGER *sk) { return (ASN1_INTEGER *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASN1_INTEGER *sk_ASN1_INTEGER_shift(struct stack_st_ASN1_INTEGER *sk) { return (ASN1_INTEGER *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASN1_INTEGER_pop_free(struct stack_st_ASN1_INTEGER *sk, sk_ASN1_INTEGER_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASN1_INTEGER_insert(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASN1_INTEGER *sk_ASN1_INTEGER_set(struct stack_st_ASN1_INTEGER *sk, int idx, ASN1_INTEGER *ptr) { return (ASN1_INTEGER *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASN1_INTEGER_find(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_INTEGER_find_ex(struct stack_st_ASN1_INTEGER *sk, ASN1_INTEGER *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASN1_INTEGER_sort(struct stack_st_ASN1_INTEGER *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASN1_INTEGER_is_sorted(const struct stack_st_ASN1_INTEGER *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_INTEGER * sk_ASN1_INTEGER_dup(const struct stack_st_ASN1_INTEGER *sk) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_INTEGER *sk_ASN1_INTEGER_deep_copy(const struct stack_st_ASN1_INTEGER *sk, sk_ASN1_INTEGER_copyfunc copyfunc, sk_ASN1_INTEGER_freefunc freefunc) { return (struct stack_st_ASN1_INTEGER *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASN1_INTEGER_compfunc sk_ASN1_INTEGER_set_cmp_func(struct stack_st_ASN1_INTEGER *sk, sk_ASN1_INTEGER_compfunc compare) { return (sk_ASN1_INTEGER_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>struct stack_st_ASN1_GENERALSTRING; typedef int (*sk_ASN1_GENERALSTRING_compfunc)(const ASN1_GENERALSTRING * const *a, const ASN1_GENERALSTRING *const *b); typedef void (*sk_ASN1_GENERALSTRING_freefunc)(ASN1_GENERALSTRING *a); typedef ASN1_GENERALSTRING * (*sk_ASN1_GENERALSTRING_copyfunc)(const ASN1_GENERALSTRING *a); static inline int sk_ASN1_GENERALSTRING_num(const struct stack_st_ASN1_GENERALSTRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_value(const struct stack_st_ASN1_GENERALSTRING *sk, int idx) { return (ASN1_GENERALSTRING *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_new(sk_ASN1_GENERALSTRING_compfunc compare) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_new_null(void) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_new_null(); } static inline void sk_ASN1_GENERALSTRING_free(struct stack_st_ASN1_GENERALSTRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASN1_GENERALSTRING_zero(struct stack_st_ASN1_GENERALSTRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_delete(struct stack_st_ASN1_GENERALSTRING *sk, int i) { return (ASN1_GENERALSTRING *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_delete_ptr(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return (ASN1_GENERALSTRING *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_GENERALSTRING_push(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_GENERALSTRING_unshift(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_pop(struct stack_st_ASN1_GENERALSTRING *sk) { return (ASN1_GENERALSTRING *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_shift(struct stack_st_ASN1_GENERALSTRING *sk) { return (ASN1_GENERALSTRING *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASN1_GENERALSTRING_pop_free(struct stack_st_ASN1_GENERALSTRING *sk, sk_ASN1_GENERALSTRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASN1_GENERALSTRING_insert(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_set(struct stack_st_ASN1_GENERALSTRING *sk, int idx, ASN1_GENERALSTRING *ptr) { return (ASN1_GENERALSTRING *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASN1_GENERALSTRING_find(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_GENERALSTRING_find_ex(struct stack_st_ASN1_GENERALSTRING *sk, ASN1_GENERALSTRING *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASN1_GENERALSTRING_sort(struct stack_st_ASN1_GENERALSTRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASN1_GENERALSTRING_is_sorted(const struct stack_st_ASN1_GENERALSTRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_GENERALSTRING * sk_ASN1_GENERALSTRING_dup(const struct stack_st_ASN1_GENERALSTRING *sk) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_GENERALSTRING *sk_ASN1_GENERALSTRING_deep_copy(const struct stack_st_ASN1_GENERALSTRING *sk, sk_ASN1_GENERALSTRING_copyfunc copyfunc, sk_ASN1_GENERALSTRING_freefunc freefunc) { return (struct stack_st_ASN1_GENERALSTRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASN1_GENERALSTRING_compfunc sk_ASN1_GENERALSTRING_set_cmp_func(struct stack_st_ASN1_GENERALSTRING *sk, sk_ASN1_GENERALSTRING_compfunc compare) { return (sk_ASN1_GENERALSTRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>struct stack_st_ASN1_UTF8STRING; typedef int (*sk_ASN1_UTF8STRING_compfunc)(const ASN1_UTF8STRING * const *a, const ASN1_UTF8STRING *const *b); typedef void (*sk_ASN1_UTF8STRING_freefunc)(ASN1_UTF8STRING *a); typedef ASN1_UTF8STRING * (*sk_ASN1_UTF8STRING_copyfunc)(const ASN1_UTF8STRING *a); static inline int sk_ASN1_UTF8STRING_num(const struct stack_st_ASN1_UTF8STRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_value(const struct stack_st_ASN1_UTF8STRING *sk, int idx) { return (ASN1_UTF8STRING *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_new(sk_ASN1_UTF8STRING_compfunc compare) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_new_null(void) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_new_null(); } static inline void sk_ASN1_UTF8STRING_free(struct stack_st_ASN1_UTF8STRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASN1_UTF8STRING_zero(struct stack_st_ASN1_UTF8STRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_delete(struct stack_st_ASN1_UTF8STRING *sk, int i) { return (ASN1_UTF8STRING *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_delete_ptr(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return (ASN1_UTF8STRING *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_UTF8STRING_push(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_UTF8STRING_unshift(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_pop(struct stack_st_ASN1_UTF8STRING *sk) { return (ASN1_UTF8STRING *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_shift(struct stack_st_ASN1_UTF8STRING *sk) { return (ASN1_UTF8STRING *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASN1_UTF8STRING_pop_free(struct stack_st_ASN1_UTF8STRING *sk, sk_ASN1_UTF8STRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASN1_UTF8STRING_insert(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASN1_UTF8STRING *sk_ASN1_UTF8STRING_set(struct stack_st_ASN1_UTF8STRING *sk, int idx, ASN1_UTF8STRING *ptr) { return (ASN1_UTF8STRING *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASN1_UTF8STRING_find(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_UTF8STRING_find_ex(struct stack_st_ASN1_UTF8STRING *sk, ASN1_UTF8STRING *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASN1_UTF8STRING_sort(struct stack_st_ASN1_UTF8STRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASN1_UTF8STRING_is_sorted(const struct stack_st_ASN1_UTF8STRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_UTF8STRING * sk_ASN1_UTF8STRING_dup(const struct stack_st_ASN1_UTF8STRING *sk) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_UTF8STRING *sk_ASN1_UTF8STRING_deep_copy(const struct stack_st_ASN1_UTF8STRING *sk, sk_ASN1_UTF8STRING_copyfunc copyfunc, sk_ASN1_UTF8STRING_freefunc freefunc) { return (struct stack_st_ASN1_UTF8STRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASN1_UTF8STRING_compfunc sk_ASN1_UTF8STRING_set_cmp_func(struct stack_st_ASN1_UTF8STRING *sk, sk_ASN1_UTF8STRING_compfunc compare) { return (sk_ASN1_UTF8STRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct asn1_type_st {
> int type;
> union {
> char *ptr;
> ASN1_BOOLEAN boolean;
> ASN1_STRING *asn1_string;
> ASN1_OBJECT *object;
> ASN1_INTEGER *integer;
> ASN1_ENUMERATED *enumerated;
> ASN1_BIT_STRING *bit_string;
> ASN1_OCTET_STRING *octet_string;
> ASN1_PRINTABLESTRING *printablestring;
> ASN1_T61STRING *t61string;
> ASN1_IA5STRING *ia5string;
> ASN1_GENERALSTRING *generalstring;
> ASN1_BMPSTRING *bmpstring;
> ASN1_UNIVERSALSTRING *universalstring;
> ASN1_UTCTIME *utctime;
> ASN1_GENERALIZEDTIME *generalizedtime;
> ASN1_VISIBLESTRING *visiblestring;
> ASN1_UTF8STRING *utf8string;
>
>
>
>
> ASN1_STRING *set;
> ASN1_STRING *sequence;
> ASN1_VALUE *asn1_value;
> } value;
>} ASN1_TYPE;
>
>struct stack_st_ASN1_TYPE; typedef int (*sk_ASN1_TYPE_compfunc)(const ASN1_TYPE * const *a, const ASN1_TYPE *const *b); typedef void (*sk_ASN1_TYPE_freefunc)(ASN1_TYPE *a); typedef ASN1_TYPE * (*sk_ASN1_TYPE_copyfunc)(const ASN1_TYPE *a); static inline int sk_ASN1_TYPE_num(const struct stack_st_ASN1_TYPE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASN1_TYPE *sk_ASN1_TYPE_value(const struct stack_st_ASN1_TYPE *sk, int idx) { return (ASN1_TYPE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_new(sk_ASN1_TYPE_compfunc compare) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_new_null(void) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_new_null(); } static inline void sk_ASN1_TYPE_free(struct stack_st_ASN1_TYPE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASN1_TYPE_zero(struct stack_st_ASN1_TYPE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASN1_TYPE *sk_ASN1_TYPE_delete(struct stack_st_ASN1_TYPE *sk, int i) { return (ASN1_TYPE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASN1_TYPE *sk_ASN1_TYPE_delete_ptr(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return (ASN1_TYPE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_TYPE_push(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_TYPE_unshift(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASN1_TYPE *sk_ASN1_TYPE_pop(struct stack_st_ASN1_TYPE *sk) { return (ASN1_TYPE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASN1_TYPE *sk_ASN1_TYPE_shift(struct stack_st_ASN1_TYPE *sk) { return (ASN1_TYPE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASN1_TYPE_pop_free(struct stack_st_ASN1_TYPE *sk, sk_ASN1_TYPE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASN1_TYPE_insert(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASN1_TYPE *sk_ASN1_TYPE_set(struct stack_st_ASN1_TYPE *sk, int idx, ASN1_TYPE *ptr) { return (ASN1_TYPE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASN1_TYPE_find(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_TYPE_find_ex(struct stack_st_ASN1_TYPE *sk, ASN1_TYPE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASN1_TYPE_sort(struct stack_st_ASN1_TYPE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASN1_TYPE_is_sorted(const struct stack_st_ASN1_TYPE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_TYPE * sk_ASN1_TYPE_dup(const struct stack_st_ASN1_TYPE *sk) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_TYPE *sk_ASN1_TYPE_deep_copy(const struct stack_st_ASN1_TYPE *sk, sk_ASN1_TYPE_copyfunc copyfunc, sk_ASN1_TYPE_freefunc freefunc) { return (struct stack_st_ASN1_TYPE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASN1_TYPE_compfunc sk_ASN1_TYPE_set_cmp_func(struct stack_st_ASN1_TYPE *sk, sk_ASN1_TYPE_compfunc compare) { return (sk_ASN1_TYPE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct stack_st_ASN1_TYPE ASN1_SEQUENCE_ANY;
>
>ASN1_SEQUENCE_ANY *d2i_ASN1_SEQUENCE_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len); int i2d_ASN1_SEQUENCE_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out); extern const ASN1_ITEM ASN1_SEQUENCE_ANY_it;
>ASN1_SEQUENCE_ANY *d2i_ASN1_SET_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len); int i2d_ASN1_SET_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out); extern const ASN1_ITEM ASN1_SET_ANY_it;
>
>
>typedef struct BIT_STRING_BITNAME_st {
> int bitnum;
> const char *lname;
> const char *sname;
>} BIT_STRING_BITNAME;
># 517 "/usr/include/openssl/asn1.h" 3 4
>ASN1_TYPE *ASN1_TYPE_new(void); void ASN1_TYPE_free(ASN1_TYPE *a); ASN1_TYPE *d2i_ASN1_TYPE(ASN1_TYPE **a, const unsigned char **in, long len); int i2d_ASN1_TYPE(ASN1_TYPE *a, unsigned char **out); extern const ASN1_ITEM ASN1_ANY_it;
>
>int ASN1_TYPE_get(const ASN1_TYPE *a);
>void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value);
>int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value);
>int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b);
>
>ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t);
>void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t);
>
>ASN1_OBJECT *ASN1_OBJECT_new(void);
>void ASN1_OBJECT_free(ASN1_OBJECT *a);
>int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp);
>ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
> long length);
>
>extern const ASN1_ITEM ASN1_OBJECT_it;
>
>struct stack_st_ASN1_OBJECT; typedef int (*sk_ASN1_OBJECT_compfunc)(const ASN1_OBJECT * const *a, const ASN1_OBJECT *const *b); typedef void (*sk_ASN1_OBJECT_freefunc)(ASN1_OBJECT *a); typedef ASN1_OBJECT * (*sk_ASN1_OBJECT_copyfunc)(const ASN1_OBJECT *a); static inline int sk_ASN1_OBJECT_num(const struct stack_st_ASN1_OBJECT *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASN1_OBJECT *sk_ASN1_OBJECT_value(const struct stack_st_ASN1_OBJECT *sk, int idx) { return (ASN1_OBJECT *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_new(sk_ASN1_OBJECT_compfunc compare) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_new_null(void) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_new_null(); } static inline void sk_ASN1_OBJECT_free(struct stack_st_ASN1_OBJECT *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASN1_OBJECT_zero(struct stack_st_ASN1_OBJECT *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASN1_OBJECT *sk_ASN1_OBJECT_delete(struct stack_st_ASN1_OBJECT *sk, int i) { return (ASN1_OBJECT *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASN1_OBJECT *sk_ASN1_OBJECT_delete_ptr(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return (ASN1_OBJECT *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_OBJECT_push(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_OBJECT_unshift(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASN1_OBJECT *sk_ASN1_OBJECT_pop(struct stack_st_ASN1_OBJECT *sk) { return (ASN1_OBJECT *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASN1_OBJECT *sk_ASN1_OBJECT_shift(struct stack_st_ASN1_OBJECT *sk) { return (ASN1_OBJECT *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASN1_OBJECT_pop_free(struct stack_st_ASN1_OBJECT *sk, sk_ASN1_OBJECT_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASN1_OBJECT_insert(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASN1_OBJECT *sk_ASN1_OBJECT_set(struct stack_st_ASN1_OBJECT *sk, int idx, ASN1_OBJECT *ptr) { return (ASN1_OBJECT *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASN1_OBJECT_find(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASN1_OBJECT_find_ex(struct stack_st_ASN1_OBJECT *sk, ASN1_OBJECT *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASN1_OBJECT_sort(struct stack_st_ASN1_OBJECT *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASN1_OBJECT_is_sorted(const struct stack_st_ASN1_OBJECT *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_OBJECT * sk_ASN1_OBJECT_dup(const struct stack_st_ASN1_OBJECT *sk) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASN1_OBJECT *sk_ASN1_OBJECT_deep_copy(const struct stack_st_ASN1_OBJECT *sk, sk_ASN1_OBJECT_copyfunc copyfunc, sk_ASN1_OBJECT_freefunc freefunc) { return (struct stack_st_ASN1_OBJECT *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASN1_OBJECT_compfunc sk_ASN1_OBJECT_set_cmp_func(struct stack_st_ASN1_OBJECT *sk, sk_ASN1_OBJECT_compfunc compare) { return (sk_ASN1_OBJECT_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>ASN1_STRING *ASN1_STRING_new(void);
>void ASN1_STRING_free(ASN1_STRING *a);
>void ASN1_STRING_clear_free(ASN1_STRING *a);
>int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str);
>ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a);
>ASN1_STRING *ASN1_STRING_type_new(int type);
>int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b);
>
>
>
>
>int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len);
>void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len);
>int ASN1_STRING_length(const ASN1_STRING *x);
>void ASN1_STRING_length_set(ASN1_STRING *x, int n);
>int ASN1_STRING_type(const ASN1_STRING *x);
>unsigned char *ASN1_STRING_data(ASN1_STRING *x) __attribute__ ((deprecated));
>const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x);
>
>ASN1_BIT_STRING *ASN1_BIT_STRING_new(void); void ASN1_BIT_STRING_free(ASN1_BIT_STRING *a); ASN1_BIT_STRING *d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **in, long len); int i2d_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_BIT_STRING_it;
>int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length);
>int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value);
>int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n);
>int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a,
> const unsigned char *flags, int flags_len);
>
>int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs,
> BIT_STRING_BITNAME *tbl, int indent);
>int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl);
>int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value,
> BIT_STRING_BITNAME *tbl);
>
>ASN1_INTEGER *ASN1_INTEGER_new(void); void ASN1_INTEGER_free(ASN1_INTEGER *a); ASN1_INTEGER *d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len); int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out); extern const ASN1_ITEM ASN1_INTEGER_it;
>ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
> long length);
>ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x);
>int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y);
>
>ASN1_ENUMERATED *ASN1_ENUMERATED_new(void); void ASN1_ENUMERATED_free(ASN1_ENUMERATED *a); ASN1_ENUMERATED *d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, const unsigned char **in, long len); int i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **out); extern const ASN1_ITEM ASN1_ENUMERATED_it;
>
>int ASN1_UTCTIME_check(const ASN1_UTCTIME *a);
>ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t);
>ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
> int offset_day, long offset_sec);
>int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str);
>int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t);
>
>int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a);
>ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s,
> time_t t);
>ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
> time_t t, int offset_day,
> long offset_sec);
>int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str);
>int ASN1_TIME_diff(int *pday, int *psec,
> const ASN1_TIME *from, const ASN1_TIME *to);
>
>ASN1_OCTET_STRING *ASN1_OCTET_STRING_new(void); void ASN1_OCTET_STRING_free(ASN1_OCTET_STRING *a); ASN1_OCTET_STRING *d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a, const unsigned char **in, long len); int i2d_ASN1_OCTET_STRING(ASN1_OCTET_STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_OCTET_STRING_it;
>ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a);
>int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a,
> const ASN1_OCTET_STRING *b);
>int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data,
> int len);
>
>ASN1_VISIBLESTRING *ASN1_VISIBLESTRING_new(void); void ASN1_VISIBLESTRING_free(ASN1_VISIBLESTRING *a); ASN1_VISIBLESTRING *d2i_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING **a, const unsigned char **in, long len); int i2d_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_VISIBLESTRING_it;
>ASN1_UNIVERSALSTRING *ASN1_UNIVERSALSTRING_new(void); void ASN1_UNIVERSALSTRING_free(ASN1_UNIVERSALSTRING *a); ASN1_UNIVERSALSTRING *d2i_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING **a, const unsigned char **in, long len); int i2d_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_UNIVERSALSTRING_it;
>ASN1_UTF8STRING *ASN1_UTF8STRING_new(void); void ASN1_UTF8STRING_free(ASN1_UTF8STRING *a); ASN1_UTF8STRING *d2i_ASN1_UTF8STRING(ASN1_UTF8STRING **a, const unsigned char **in, long len); int i2d_ASN1_UTF8STRING(ASN1_UTF8STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_UTF8STRING_it;
>ASN1_NULL *ASN1_NULL_new(void); void ASN1_NULL_free(ASN1_NULL *a); ASN1_NULL *d2i_ASN1_NULL(ASN1_NULL **a, const unsigned char **in, long len); int i2d_ASN1_NULL(ASN1_NULL *a, unsigned char **out); extern const ASN1_ITEM ASN1_NULL_it;
>ASN1_BMPSTRING *ASN1_BMPSTRING_new(void); void ASN1_BMPSTRING_free(ASN1_BMPSTRING *a); ASN1_BMPSTRING *d2i_ASN1_BMPSTRING(ASN1_BMPSTRING **a, const unsigned char **in, long len); int i2d_ASN1_BMPSTRING(ASN1_BMPSTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_BMPSTRING_it;
>
>int UTF8_getc(const unsigned char *str, int len, unsigned long *val);
>int UTF8_putc(unsigned char *str, int len, unsigned long value);
>
>ASN1_STRING *ASN1_PRINTABLE_new(void); void ASN1_PRINTABLE_free(ASN1_STRING *a); ASN1_STRING *d2i_ASN1_PRINTABLE(ASN1_STRING **a, const unsigned char **in, long len); int i2d_ASN1_PRINTABLE(ASN1_STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_PRINTABLE_it;
>
>ASN1_STRING *DIRECTORYSTRING_new(void); void DIRECTORYSTRING_free(ASN1_STRING *a); ASN1_STRING *d2i_DIRECTORYSTRING(ASN1_STRING **a, const unsigned char **in, long len); int i2d_DIRECTORYSTRING(ASN1_STRING *a, unsigned char **out); extern const ASN1_ITEM DIRECTORYSTRING_it;
>ASN1_STRING *DISPLAYTEXT_new(void); void DISPLAYTEXT_free(ASN1_STRING *a); ASN1_STRING *d2i_DISPLAYTEXT(ASN1_STRING **a, const unsigned char **in, long len); int i2d_DISPLAYTEXT(ASN1_STRING *a, unsigned char **out); extern const ASN1_ITEM DISPLAYTEXT_it;
>ASN1_PRINTABLESTRING *ASN1_PRINTABLESTRING_new(void); void ASN1_PRINTABLESTRING_free(ASN1_PRINTABLESTRING *a); ASN1_PRINTABLESTRING *d2i_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING **a, const unsigned char **in, long len); int i2d_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_PRINTABLESTRING_it;
>ASN1_T61STRING *ASN1_T61STRING_new(void); void ASN1_T61STRING_free(ASN1_T61STRING *a); ASN1_T61STRING *d2i_ASN1_T61STRING(ASN1_T61STRING **a, const unsigned char **in, long len); int i2d_ASN1_T61STRING(ASN1_T61STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_T61STRING_it;
>ASN1_IA5STRING *ASN1_IA5STRING_new(void); void ASN1_IA5STRING_free(ASN1_IA5STRING *a); ASN1_IA5STRING *d2i_ASN1_IA5STRING(ASN1_IA5STRING **a, const unsigned char **in, long len); int i2d_ASN1_IA5STRING(ASN1_IA5STRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_IA5STRING_it;
>ASN1_GENERALSTRING *ASN1_GENERALSTRING_new(void); void ASN1_GENERALSTRING_free(ASN1_GENERALSTRING *a); ASN1_GENERALSTRING *d2i_ASN1_GENERALSTRING(ASN1_GENERALSTRING **a, const unsigned char **in, long len); int i2d_ASN1_GENERALSTRING(ASN1_GENERALSTRING *a, unsigned char **out); extern const ASN1_ITEM ASN1_GENERALSTRING_it;
>ASN1_UTCTIME *ASN1_UTCTIME_new(void); void ASN1_UTCTIME_free(ASN1_UTCTIME *a); ASN1_UTCTIME *d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, const unsigned char **in, long len); int i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **out); extern const ASN1_ITEM ASN1_UTCTIME_it;
>ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_new(void); void ASN1_GENERALIZEDTIME_free(ASN1_GENERALIZEDTIME *a); ASN1_GENERALIZEDTIME *d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a, const unsigned char **in, long len); int i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **out); extern const ASN1_ITEM ASN1_GENERALIZEDTIME_it;
>ASN1_TIME *ASN1_TIME_new(void); void ASN1_TIME_free(ASN1_TIME *a); ASN1_TIME *d2i_ASN1_TIME(ASN1_TIME **a, const unsigned char **in, long len); int i2d_ASN1_TIME(ASN1_TIME *a, unsigned char **out); extern const ASN1_ITEM ASN1_TIME_it;
>
>extern const ASN1_ITEM ASN1_OCTET_STRING_NDEF_it;
>
>ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t);
>ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t,
> int offset_day, long offset_sec);
>int ASN1_TIME_check(const ASN1_TIME *t);
>ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t,
> ASN1_GENERALIZEDTIME **out);
>int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
>
>int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a);
>int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size);
>int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a);
>int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size);
>int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a);
>int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size);
>int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type);
>int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a);
>
>int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num);
>ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len,
> const char *sn, const char *ln);
>
>int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a);
>int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r);
>int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a);
>int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r);
>
>int ASN1_INTEGER_set(ASN1_INTEGER *a, long v);
>long ASN1_INTEGER_get(const ASN1_INTEGER *a);
>ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai);
>BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn);
>
>int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a);
>int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r);
>
>
>int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v);
>long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a);
>ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai);
>BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn);
>
>
>
>int ASN1_PRINTABLE_type(const unsigned char *s, int max);
>
>unsigned long ASN1_tag2bit(int tag);
>
>
>int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag,
> int *pclass, long omax);
>int ASN1_check_infinite_end(unsigned char **p, long len);
>int ASN1_const_check_infinite_end(const unsigned char **p, long len);
>void ASN1_put_object(unsigned char **pp, int constructed, int length,
> int tag, int xclass);
>int ASN1_put_eoc(unsigned char **pp);
>int ASN1_object_size(int constructed, int length, int tag);
>
>
>void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x);
># 693 "/usr/include/openssl/asn1.h" 3 4
>void *ASN1_item_dup(const ASN1_ITEM *it, void *x);
># 702 "/usr/include/openssl/asn1.h" 3 4
>void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x);
>
>
>
>
>
>
>
>void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x);
>int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x);
># 723 "/usr/include/openssl/asn1.h" 3 4
>int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x);
>int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags);
>
>
>int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in);
>
>void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x);
>
>
>
>
>
>
>
>void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x);
>int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x);
># 750 "/usr/include/openssl/asn1.h" 3 4
>int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x);
>int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a);
>int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a);
>int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a);
>int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v);
>int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags);
>int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off);
>int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num,
> unsigned char *buf, int off);
>int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent);
>int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent,
> int dump);
>const char *ASN1_tag2str(int tag);
>
>
>
>int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s);
>
>int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len);
>int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len);
>int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
> unsigned char *data, int len);
>int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num,
> unsigned char *data, int max_len);
>
>void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it);
>
>ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it,
> ASN1_OCTET_STRING **oct);
>
>void ASN1_STRING_set_default_mask(unsigned long mask);
>int ASN1_STRING_set_default_mask_asc(const char *p);
>unsigned long ASN1_STRING_get_default_mask(void);
>int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
> int inform, unsigned long mask);
>int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
> int inform, unsigned long mask,
> long minsize, long maxsize);
>
>ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out,
> const unsigned char *in, int inlen,
> int inform, int nid);
>ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid);
>int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long);
>void ASN1_STRING_TABLE_cleanup(void);
>
>
>
>
>ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it);
>void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it);
>ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in,
> long len, const ASN1_ITEM *it);
>int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it);
>int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out,
> const ASN1_ITEM *it);
>
>void ASN1_add_oid_module(void);
>void ASN1_add_stable_module(void);
>
>ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf);
>ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf);
>int ASN1_str2mask(const char *str, unsigned long *pmask);
># 835 "/usr/include/openssl/asn1.h" 3 4
>int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent,
> const ASN1_ITEM *it, const ASN1_PCTX *pctx);
>ASN1_PCTX *ASN1_PCTX_new(void);
>void ASN1_PCTX_free(ASN1_PCTX *p);
>unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p);
>void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags);
>unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p);
>void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags);
>unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p);
>void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags);
>unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p);
>void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags);
>unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p);
>void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags);
>
>ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx));
>void ASN1_SCTX_free(ASN1_SCTX *p);
>const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p);
>const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p);
>unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p);
>void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data);
>void *ASN1_SCTX_get_app_data(ASN1_SCTX *p);
>
>const BIO_METHOD *BIO_f_asn1(void);
>
>BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it);
>
>int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
> const ASN1_ITEM *it);
>int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
> const char *hdr, const ASN1_ITEM *it);
>int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
> int ctype_nid, int econt_nid,
> struct stack_st_X509_ALGOR *mdalgs, const ASN1_ITEM *it);
>ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it);
>int SMIME_crlf_copy(BIO *in, BIO *out, int flags);
>int SMIME_text(BIO *in, BIO *out);
>
>
>
>
>
>
>
>int ERR_load_ASN1_strings(void);
># 1098 "/usr/include/openssl/asn1.h" 3 4
>}
># 917 "/usr/include/openssl/objects.h" 2 3 4
># 932 "/usr/include/openssl/objects.h" 3 4
>extern "C" {
>
>
>typedef struct obj_name_st {
> int type;
> int alias;
> const char *name;
> const char *data;
>} OBJ_NAME;
>
>
>
>int OBJ_NAME_init(void);
>int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *),
> int (*cmp_func) (const char *, const char *),
> void (*free_func) (const char *, int, const char *));
>const char *OBJ_NAME_get(const char *name, int type);
>int OBJ_NAME_add(const char *name, int type, const char *data);
>int OBJ_NAME_remove(const char *name, int type);
>void OBJ_NAME_cleanup(int type);
>void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg),
> void *arg);
>void OBJ_NAME_do_all_sorted(int type,
> void (*fn) (const OBJ_NAME *, void *arg),
> void *arg);
>
>ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o);
>ASN1_OBJECT *OBJ_nid2obj(int n);
>const char *OBJ_nid2ln(int n);
>const char *OBJ_nid2sn(int n);
>int OBJ_obj2nid(const ASN1_OBJECT *o);
>ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name);
>int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name);
>int OBJ_txt2nid(const char *s);
>int OBJ_ln2nid(const char *s);
>int OBJ_sn2nid(const char *s);
>int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b);
>const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
> int (*cmp) (const void *, const void *));
>const void *OBJ_bsearch_ex_(const void *key, const void *base, int num,
> int size,
> int (*cmp) (const void *, const void *),
> int flags);
># 1055 "/usr/include/openssl/objects.h" 3 4
>int OBJ_new_nid(int num);
>int OBJ_add_object(const ASN1_OBJECT *obj);
>int OBJ_create(const char *oid, const char *sn, const char *ln);
>
>
>
>int OBJ_create_objects(BIO *in);
>
>size_t OBJ_length(const ASN1_OBJECT *obj);
>const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj);
>
>int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid);
>int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid);
>int OBJ_add_sigid(int signid, int dig_id, int pkey_id);
>void OBJ_sigid_free(void);
>
>
>
>
>
>
>
>int ERR_load_OBJ_strings(void);
># 1095 "/usr/include/openssl/objects.h" 3 4
>}
># 28 "/usr/include/openssl/evp.h" 2 3 4
># 57 "/usr/include/openssl/evp.h" 3 4
>extern "C" {
># 66 "/usr/include/openssl/evp.h" 3 4
>EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type);
>EVP_MD *EVP_MD_meth_dup(const EVP_MD *md);
>void EVP_MD_meth_free(EVP_MD *md);
>
>int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize);
>int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize);
>int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize);
>int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags);
>int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx));
>int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,
> const void *data,
> size_t count));
>int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,
> unsigned char *md));
>int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,
> const EVP_MD_CTX *from));
>int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx));
>int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,
> int p1, void *p2));
>
>int EVP_MD_meth_get_input_blocksize(const EVP_MD *md);
>int EVP_MD_meth_get_result_size(const EVP_MD *md);
>int EVP_MD_meth_get_app_datasize(const EVP_MD *md);
>unsigned long EVP_MD_meth_get_flags(const EVP_MD *md);
>int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx);
>int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,
> const void *data,
> size_t count);
>int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,
> unsigned char *md);
>int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,
> const EVP_MD_CTX *from);
>int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx);
>int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,
> int p1, void *p2);
># 170 "/usr/include/openssl/evp.h" 3 4
>EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len);
>EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher);
>void EVP_CIPHER_meth_free(EVP_CIPHER *cipher);
>
>int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len);
>int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags);
>int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size);
>int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher,
> int (*init) (EVP_CIPHER_CTX *ctx,
> const unsigned char *key,
> const unsigned char *iv,
> int enc));
>int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher,
> int (*do_cipher) (EVP_CIPHER_CTX *ctx,
> unsigned char *out,
> const unsigned char *in,
> size_t inl));
>int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher,
> int (*cleanup) (EVP_CIPHER_CTX *));
>int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher,
> int (*set_asn1_parameters) (EVP_CIPHER_CTX *,
> ASN1_TYPE *));
>int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher,
> int (*get_asn1_parameters) (EVP_CIPHER_CTX *,
> ASN1_TYPE *));
>int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher,
> int (*ctrl) (EVP_CIPHER_CTX *, int type,
> int arg, void *ptr));
>
>int (*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
> const unsigned char *key,
> const unsigned char *iv,
> int enc);
>int (*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx,
> unsigned char *out,
> const unsigned char *in,
> size_t inl);
>int (*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *);
>int (*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
> ASN1_TYPE *);
>int (*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
> ASN1_TYPE *);
>int (*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *,
> int type, int arg,
> void *ptr);
># 347 "/usr/include/openssl/evp.h" 3 4
>typedef struct {
> unsigned char *out;
> const unsigned char *inp;
> size_t len;
> unsigned int interleave;
>} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM;
># 368 "/usr/include/openssl/evp.h" 3 4
>typedef struct evp_cipher_info_st {
> const EVP_CIPHER *cipher;
> unsigned char iv[16];
>} EVP_CIPHER_INFO;
>
>
>
>typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass,
> int passlen, ASN1_TYPE *param,
> const EVP_CIPHER *cipher, const EVP_MD *md,
> int en_de);
># 406 "/usr/include/openssl/evp.h" 3 4
>int EVP_MD_type(const EVP_MD *md);
>
>
>int EVP_MD_pkey_type(const EVP_MD *md);
>int EVP_MD_size(const EVP_MD *md);
>int EVP_MD_block_size(const EVP_MD *md);
>unsigned long EVP_MD_flags(const EVP_MD *md);
>
>const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx);
>int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx,
> const void *data, size_t count);
>void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx,
> int (*update) (EVP_MD_CTX *ctx,
> const void *data, size_t count));
>
>
>
>EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx);
>void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx);
>
>int EVP_CIPHER_nid(const EVP_CIPHER *cipher);
>
>int EVP_CIPHER_block_size(const EVP_CIPHER *cipher);
>int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher);
>int EVP_CIPHER_key_length(const EVP_CIPHER *cipher);
>int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher);
>unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher);
>
>
>const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx);
>int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx);
>int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx);
>int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx);
>int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx);
>int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx);
>const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx);
>const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx);
>unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx);
>unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx);
>int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx);
>void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num);
>int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
>void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
>void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
>void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx);
>void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data);
># 483 "/usr/include/openssl/evp.h" 3 4
> int EVP_Cipher(EVP_CIPHER_CTX *c,
> unsigned char *out,
> const unsigned char *in, unsigned int inl);
># 496 "/usr/include/openssl/evp.h" 3 4
>int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
>EVP_MD_CTX *EVP_MD_CTX_new(void);
>int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
>void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
>
>
>
> int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in);
>void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
>void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);
>int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags);
> int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type,
> ENGINE *impl);
> int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d,
> size_t cnt);
> int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md,
> unsigned int *s);
> int EVP_Digest(const void *data, size_t count,
> unsigned char *md, unsigned int *size,
> const EVP_MD *type, ENGINE *impl);
>
> int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in);
> int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type);
> int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md,
> unsigned int *s);
>
>
>int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify);
>int EVP_read_pw_string_min(char *buf, int minlen, int maxlen,
> const char *prompt, int verify);
>void EVP_set_pw_prompt(const char *prompt);
>char *EVP_get_pw_prompt(void);
>
>
> int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md,
> const unsigned char *salt,
> const unsigned char *data, int datal, int count,
> unsigned char *key, unsigned char *iv);
>
>void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags);
>void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags);
>int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags);
>
> int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
> const unsigned char *key, const unsigned char *iv);
> int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,
> const EVP_CIPHER *cipher, ENGINE *impl,
> const unsigned char *key,
> const unsigned char *iv);
> int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
> int *outl, const unsigned char *in, int inl);
> int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out,
> int *outl);
> int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out,
> int *outl);
>
> int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
> const unsigned char *key, const unsigned char *iv);
> int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx,
> const EVP_CIPHER *cipher, ENGINE *impl,
> const unsigned char *key,
> const unsigned char *iv);
> int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
> int *outl, const unsigned char *in, int inl);
> int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
> int *outl);
> int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
> int *outl);
>
> int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
> const unsigned char *key, const unsigned char *iv,
> int enc);
> int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx,
> const EVP_CIPHER *cipher, ENGINE *impl,
> const unsigned char *key,
> const unsigned char *iv, int enc);
> int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
> int *outl, const unsigned char *in, int inl);
> int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm,
> int *outl);
> int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm,
> int *outl);
>
> int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s,
> EVP_PKEY *pkey);
>
> int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf,
> unsigned int siglen, EVP_PKEY *pkey);
>
> int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
> const EVP_MD *type, ENGINE *e,
> EVP_PKEY *pkey);
> int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
> size_t *siglen);
>
> int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx,
> const EVP_MD *type, ENGINE *e,
> EVP_PKEY *pkey);
> int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig,
> size_t siglen);
>
>
> int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
> const unsigned char *ek, int ekl,
> const unsigned char *iv, EVP_PKEY *priv);
> int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
>
> int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
> unsigned char **ek, int *ekl, unsigned char *iv,
> EVP_PKEY **pubk, int npubk);
> int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl);
>
>
>EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void);
>void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx);
>int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, EVP_ENCODE_CTX *sctx);
>int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx);
>void EVP_EncodeInit(EVP_ENCODE_CTX *ctx);
>int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
> const unsigned char *in, int inl);
>void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl);
>int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n);
>
>void EVP_DecodeInit(EVP_ENCODE_CTX *ctx);
>int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
> const unsigned char *in, int inl);
>int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned
> char *out, int *outl);
>int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n);
>
>
>
>
>
>EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void);
>int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c);
>void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c);
>int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen);
>int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad);
>int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
>int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key);
>
>const BIO_METHOD *BIO_f_md(void);
>const BIO_METHOD *BIO_f_base64(void);
>const BIO_METHOD *BIO_f_cipher(void);
>const BIO_METHOD *BIO_f_reliable(void);
> int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
> const unsigned char *i, int enc);
>
>const EVP_MD *EVP_md_null(void);
>
>const EVP_MD *EVP_md2(void);
>
>
>const EVP_MD *EVP_md4(void);
>
>
>const EVP_MD *EVP_md5(void);
>const EVP_MD *EVP_md5_sha1(void);
>
>
>const EVP_MD *EVP_blake2b512(void);
>const EVP_MD *EVP_blake2s256(void);
>
>const EVP_MD *EVP_sha1(void);
>const EVP_MD *EVP_sha224(void);
>const EVP_MD *EVP_sha256(void);
>const EVP_MD *EVP_sha384(void);
>const EVP_MD *EVP_sha512(void);
>
>
>
>
>const EVP_MD *EVP_ripemd160(void);
>
>
>const EVP_MD *EVP_whirlpool(void);
>
>const EVP_CIPHER *EVP_enc_null(void);
>
>const EVP_CIPHER *EVP_des_ecb(void);
>const EVP_CIPHER *EVP_des_ede(void);
>const EVP_CIPHER *EVP_des_ede3(void);
>const EVP_CIPHER *EVP_des_ede_ecb(void);
>const EVP_CIPHER *EVP_des_ede3_ecb(void);
>const EVP_CIPHER *EVP_des_cfb64(void);
>
>const EVP_CIPHER *EVP_des_cfb1(void);
>const EVP_CIPHER *EVP_des_cfb8(void);
>const EVP_CIPHER *EVP_des_ede_cfb64(void);
>
>const EVP_CIPHER *EVP_des_ede3_cfb64(void);
>
>const EVP_CIPHER *EVP_des_ede3_cfb1(void);
>const EVP_CIPHER *EVP_des_ede3_cfb8(void);
>const EVP_CIPHER *EVP_des_ofb(void);
>const EVP_CIPHER *EVP_des_ede_ofb(void);
>const EVP_CIPHER *EVP_des_ede3_ofb(void);
>const EVP_CIPHER *EVP_des_cbc(void);
>const EVP_CIPHER *EVP_des_ede_cbc(void);
>const EVP_CIPHER *EVP_des_ede3_cbc(void);
>const EVP_CIPHER *EVP_desx_cbc(void);
>const EVP_CIPHER *EVP_des_ede3_wrap(void);
>
>
>
>
>
>
>
>const EVP_CIPHER *EVP_rc4(void);
>const EVP_CIPHER *EVP_rc4_40(void);
>
>const EVP_CIPHER *EVP_rc4_hmac_md5(void);
>
>
>
>const EVP_CIPHER *EVP_idea_ecb(void);
>const EVP_CIPHER *EVP_idea_cfb64(void);
>
>const EVP_CIPHER *EVP_idea_ofb(void);
>const EVP_CIPHER *EVP_idea_cbc(void);
>
>
>const EVP_CIPHER *EVP_rc2_ecb(void);
>const EVP_CIPHER *EVP_rc2_cbc(void);
>const EVP_CIPHER *EVP_rc2_40_cbc(void);
>const EVP_CIPHER *EVP_rc2_64_cbc(void);
>const EVP_CIPHER *EVP_rc2_cfb64(void);
>
>const EVP_CIPHER *EVP_rc2_ofb(void);
>
>
>const EVP_CIPHER *EVP_bf_ecb(void);
>const EVP_CIPHER *EVP_bf_cbc(void);
>const EVP_CIPHER *EVP_bf_cfb64(void);
>
>const EVP_CIPHER *EVP_bf_ofb(void);
>
>
>const EVP_CIPHER *EVP_cast5_ecb(void);
>const EVP_CIPHER *EVP_cast5_cbc(void);
>const EVP_CIPHER *EVP_cast5_cfb64(void);
>
>const EVP_CIPHER *EVP_cast5_ofb(void);
>
>
>const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void);
>const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void);
>const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void);
>
>const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void);
>
>const EVP_CIPHER *EVP_aes_128_ecb(void);
>const EVP_CIPHER *EVP_aes_128_cbc(void);
>const EVP_CIPHER *EVP_aes_128_cfb1(void);
>const EVP_CIPHER *EVP_aes_128_cfb8(void);
>const EVP_CIPHER *EVP_aes_128_cfb128(void);
>
>const EVP_CIPHER *EVP_aes_128_ofb(void);
>const EVP_CIPHER *EVP_aes_128_ctr(void);
>const EVP_CIPHER *EVP_aes_128_ccm(void);
>const EVP_CIPHER *EVP_aes_128_gcm(void);
>const EVP_CIPHER *EVP_aes_128_xts(void);
>const EVP_CIPHER *EVP_aes_128_wrap(void);
>const EVP_CIPHER *EVP_aes_128_wrap_pad(void);
>
>const EVP_CIPHER *EVP_aes_128_ocb(void);
>
>const EVP_CIPHER *EVP_aes_192_ecb(void);
>const EVP_CIPHER *EVP_aes_192_cbc(void);
>const EVP_CIPHER *EVP_aes_192_cfb1(void);
>const EVP_CIPHER *EVP_aes_192_cfb8(void);
>const EVP_CIPHER *EVP_aes_192_cfb128(void);
>
>const EVP_CIPHER *EVP_aes_192_ofb(void);
>const EVP_CIPHER *EVP_aes_192_ctr(void);
>const EVP_CIPHER *EVP_aes_192_ccm(void);
>const EVP_CIPHER *EVP_aes_192_gcm(void);
>const EVP_CIPHER *EVP_aes_192_wrap(void);
>const EVP_CIPHER *EVP_aes_192_wrap_pad(void);
>
>const EVP_CIPHER *EVP_aes_192_ocb(void);
>
>const EVP_CIPHER *EVP_aes_256_ecb(void);
>const EVP_CIPHER *EVP_aes_256_cbc(void);
>const EVP_CIPHER *EVP_aes_256_cfb1(void);
>const EVP_CIPHER *EVP_aes_256_cfb8(void);
>const EVP_CIPHER *EVP_aes_256_cfb128(void);
>
>const EVP_CIPHER *EVP_aes_256_ofb(void);
>const EVP_CIPHER *EVP_aes_256_ctr(void);
>const EVP_CIPHER *EVP_aes_256_ccm(void);
>const EVP_CIPHER *EVP_aes_256_gcm(void);
>const EVP_CIPHER *EVP_aes_256_xts(void);
>const EVP_CIPHER *EVP_aes_256_wrap(void);
>const EVP_CIPHER *EVP_aes_256_wrap_pad(void);
>
>const EVP_CIPHER *EVP_aes_256_ocb(void);
>
>const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void);
>const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void);
>const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void);
>const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void);
>
>const EVP_CIPHER *EVP_camellia_128_ecb(void);
>const EVP_CIPHER *EVP_camellia_128_cbc(void);
>const EVP_CIPHER *EVP_camellia_128_cfb1(void);
>const EVP_CIPHER *EVP_camellia_128_cfb8(void);
>const EVP_CIPHER *EVP_camellia_128_cfb128(void);
>
>const EVP_CIPHER *EVP_camellia_128_ofb(void);
>const EVP_CIPHER *EVP_camellia_128_ctr(void);
>const EVP_CIPHER *EVP_camellia_192_ecb(void);
>const EVP_CIPHER *EVP_camellia_192_cbc(void);
>const EVP_CIPHER *EVP_camellia_192_cfb1(void);
>const EVP_CIPHER *EVP_camellia_192_cfb8(void);
>const EVP_CIPHER *EVP_camellia_192_cfb128(void);
>
>const EVP_CIPHER *EVP_camellia_192_ofb(void);
>const EVP_CIPHER *EVP_camellia_192_ctr(void);
>const EVP_CIPHER *EVP_camellia_256_ecb(void);
>const EVP_CIPHER *EVP_camellia_256_cbc(void);
>const EVP_CIPHER *EVP_camellia_256_cfb1(void);
>const EVP_CIPHER *EVP_camellia_256_cfb8(void);
>const EVP_CIPHER *EVP_camellia_256_cfb128(void);
>
>const EVP_CIPHER *EVP_camellia_256_ofb(void);
>const EVP_CIPHER *EVP_camellia_256_ctr(void);
>
>
>const EVP_CIPHER *EVP_chacha20(void);
>
>const EVP_CIPHER *EVP_chacha20_poly1305(void);
>
>
>
>
>const EVP_CIPHER *EVP_seed_ecb(void);
>const EVP_CIPHER *EVP_seed_cbc(void);
>const EVP_CIPHER *EVP_seed_cfb128(void);
>
>const EVP_CIPHER *EVP_seed_ofb(void);
># 869 "/usr/include/openssl/evp.h" 3 4
>int EVP_add_cipher(const EVP_CIPHER *cipher);
>int EVP_add_digest(const EVP_MD *digest);
>
>const EVP_CIPHER *EVP_get_cipherbyname(const char *name);
>const EVP_MD *EVP_get_digestbyname(const char *name);
>
>void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
> const char *from, const char *to, void *x),
> void *arg);
>void EVP_CIPHER_do_all_sorted(void (*fn)
> (const EVP_CIPHER *ciph, const char *from,
> const char *to, void *x), void *arg);
>
>void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph,
> const char *from, const char *to, void *x),
> void *arg);
>void EVP_MD_do_all_sorted(void (*fn)
> (const EVP_MD *ciph, const char *from,
> const char *to, void *x), void *arg);
>
>int EVP_PKEY_decrypt_old(unsigned char *dec_key,
> const unsigned char *enc_key, int enc_key_len,
> EVP_PKEY *private_key);
>int EVP_PKEY_encrypt_old(unsigned char *enc_key,
> const unsigned char *key, int key_len,
> EVP_PKEY *pub_key);
>int EVP_PKEY_type(int type);
>int EVP_PKEY_id(const EVP_PKEY *pkey);
>int EVP_PKEY_base_id(const EVP_PKEY *pkey);
>int EVP_PKEY_bits(const EVP_PKEY *pkey);
>int EVP_PKEY_security_bits(const EVP_PKEY *pkey);
>int EVP_PKEY_size(EVP_PKEY *pkey);
>int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
>int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
>
>int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e);
>
>int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key);
>void *EVP_PKEY_get0(const EVP_PKEY *pkey);
>const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len);
>
>
>struct rsa_st;
>int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key);
>struct rsa_st *EVP_PKEY_get0_RSA(EVP_PKEY *pkey);
>struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey);
>
>
>struct dsa_st;
>int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key);
>struct dsa_st *EVP_PKEY_get0_DSA(EVP_PKEY *pkey);
>struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey);
>
>
>struct dh_st;
>int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key);
>struct dh_st *EVP_PKEY_get0_DH(EVP_PKEY *pkey);
>struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
>
>
>struct ec_key_st;
>int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key);
>struct ec_key_st *EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey);
>struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
>
>
>EVP_PKEY *EVP_PKEY_new(void);
>int EVP_PKEY_up_ref(EVP_PKEY *pkey);
>void EVP_PKEY_free(EVP_PKEY *pkey);
>
>EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp,
> long length);
>int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp);
>
>EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp,
> long length);
>EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp,
> long length);
>int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp);
>
>int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from);
>int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey);
>int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode);
>int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b);
>
>int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b);
>
>int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey,
> int indent, ASN1_PCTX *pctx);
>int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey,
> int indent, ASN1_PCTX *pctx);
>int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey,
> int indent, ASN1_PCTX *pctx);
>
>int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid);
>
>int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey,
> const unsigned char *pt, size_t ptlen);
>size_t EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY *pkey, unsigned char **ppt);
>
>int EVP_CIPHER_type(const EVP_CIPHER *ctx);
>
>
>int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
>int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
>
>
>int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
>int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type);
>
>
>int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
> ASN1_TYPE *param, const EVP_CIPHER *cipher,
> const EVP_MD *md, int en_de);
>int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen,
> const unsigned char *salt, int saltlen, int iter,
> int keylen, unsigned char *out);
>int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
> const unsigned char *salt, int saltlen, int iter,
> const EVP_MD *digest, int keylen, unsigned char *out);
>int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
> ASN1_TYPE *param, const EVP_CIPHER *cipher,
> const EVP_MD *md, int en_de);
>
>
>int EVP_PBE_scrypt(const char *pass, size_t passlen,
> const unsigned char *salt, size_t saltlen,
> uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem,
> unsigned char *key, size_t keylen);
>
>int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass,
> int passlen, ASN1_TYPE *param,
> const EVP_CIPHER *c, const EVP_MD *md, int en_de);
>
>
>void PKCS5_PBE_add(void);
>
>int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen,
> ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de);
># 1018 "/usr/include/openssl/evp.h" 3 4
>int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid,
> int md_nid, EVP_PBE_KEYGEN *keygen);
>int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md,
> EVP_PBE_KEYGEN *keygen);
>int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid,
> EVP_PBE_KEYGEN **pkeygen);
>void EVP_PBE_cleanup(void);
>int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num);
># 1041 "/usr/include/openssl/evp.h" 3 4
>int EVP_PKEY_asn1_get_count(void);
>const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx);
>const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type);
>const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe,
> const char *str, int len);
>int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth);
>int EVP_PKEY_asn1_add_alias(int to, int from);
>int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id,
> int *ppkey_flags, const char **pinfo,
> const char **ppem_str,
> const EVP_PKEY_ASN1_METHOD *ameth);
>
>const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey);
>EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
> const char *pem_str,
> const char *info);
>void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
> const EVP_PKEY_ASN1_METHOD *src);
>void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth);
>void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth,
> int (*pub_decode) (EVP_PKEY *pk,
> X509_PUBKEY *pub),
> int (*pub_encode) (X509_PUBKEY *pub,
> const EVP_PKEY *pk),
> int (*pub_cmp) (const EVP_PKEY *a,
> const EVP_PKEY *b),
> int (*pub_print) (BIO *out,
> const EVP_PKEY *pkey,
> int indent, ASN1_PCTX *pctx),
> int (*pkey_size) (const EVP_PKEY *pk),
> int (*pkey_bits) (const EVP_PKEY *pk));
>void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth,
> int (*priv_decode) (EVP_PKEY *pk,
> const PKCS8_PRIV_KEY_INFO
> *p8inf),
> int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8,
> const EVP_PKEY *pk),
> int (*priv_print) (BIO *out,
> const EVP_PKEY *pkey,
> int indent,
> ASN1_PCTX *pctx));
>void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth,
> int (*param_decode) (EVP_PKEY *pkey,
> const unsigned char **pder,
> int derlen),
> int (*param_encode) (const EVP_PKEY *pkey,
> unsigned char **pder),
> int (*param_missing) (const EVP_PKEY *pk),
> int (*param_copy) (EVP_PKEY *to,
> const EVP_PKEY *from),
> int (*param_cmp) (const EVP_PKEY *a,
> const EVP_PKEY *b),
> int (*param_print) (BIO *out,
> const EVP_PKEY *pkey,
> int indent,
> ASN1_PCTX *pctx));
>
>void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth,
> void (*pkey_free) (EVP_PKEY *pkey));
>void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth,
> int (*pkey_ctrl) (EVP_PKEY *pkey, int op,
> long arg1, void *arg2));
>void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth,
> int (*item_verify) (EVP_MD_CTX *ctx,
> const ASN1_ITEM *it,
> void *asn,
> X509_ALGOR *a,
> ASN1_BIT_STRING *sig,
> EVP_PKEY *pkey),
> int (*item_sign) (EVP_MD_CTX *ctx,
> const ASN1_ITEM *it,
> void *asn,
> X509_ALGOR *alg1,
> X509_ALGOR *alg2,
> ASN1_BIT_STRING *sig));
>
>void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth,
> int (*pkey_security_bits) (const EVP_PKEY
> *pk));
># 1189 "/usr/include/openssl/evp.h" 3 4
>const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type);
>EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags);
>void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags,
> const EVP_PKEY_METHOD *meth);
>void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src);
>void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth);
>int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth);
>
>EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e);
>EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e);
>EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx);
>void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx);
>
>int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype,
> int cmd, int p1, void *p2);
>int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type,
> const char *value);
>
>int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str);
>int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex);
>
>int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx);
>void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen);
>
>EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
> const unsigned char *key, int keylen);
>
>void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data);
>void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx);
>EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx);
>
>EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx);
>
>void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data);
>void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx);
>
>int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
> unsigned char *sig, size_t *siglen,
> const unsigned char *tbs, size_t tbslen);
>int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
> const unsigned char *sig, size_t siglen,
> const unsigned char *tbs, size_t tbslen);
>int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
> unsigned char *rout, size_t *routlen,
> const unsigned char *sig, size_t siglen);
>int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
> unsigned char *out, size_t *outlen,
> const unsigned char *in, size_t inlen);
>int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
> unsigned char *out, size_t *outlen,
> const unsigned char *in, size_t inlen);
>
>int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer);
>int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
>
>typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx);
>
>int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
>int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx);
>int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey);
>
>void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb);
>EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx);
>
>int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx);
>
>void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth,
> int (*init) (EVP_PKEY_CTX *ctx));
>
>void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth,
> int (*copy) (EVP_PKEY_CTX *dst,
> EVP_PKEY_CTX *src));
>
>void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth,
> void (*cleanup) (EVP_PKEY_CTX *ctx));
>
>void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth,
> int (*paramgen_init) (EVP_PKEY_CTX *ctx),
> int (*paramgen) (EVP_PKEY_CTX *ctx,
> EVP_PKEY *pkey));
>
>void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth,
> int (*keygen_init) (EVP_PKEY_CTX *ctx),
> int (*keygen) (EVP_PKEY_CTX *ctx,
> EVP_PKEY *pkey));
>
>void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth,
> int (*sign_init) (EVP_PKEY_CTX *ctx),
> int (*sign) (EVP_PKEY_CTX *ctx,
> unsigned char *sig, size_t *siglen,
> const unsigned char *tbs,
> size_t tbslen));
>
>void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth,
> int (*verify_init) (EVP_PKEY_CTX *ctx),
> int (*verify) (EVP_PKEY_CTX *ctx,
> const unsigned char *sig,
> size_t siglen,
> const unsigned char *tbs,
> size_t tbslen));
>
>void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth,
> int (*verify_recover_init) (EVP_PKEY_CTX
> *ctx),
> int (*verify_recover) (EVP_PKEY_CTX
> *ctx,
> unsigned char
> *sig,
> size_t *siglen,
> const unsigned
> char *tbs,
> size_t tbslen));
>
>void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth,
> int (*signctx_init) (EVP_PKEY_CTX *ctx,
> EVP_MD_CTX *mctx),
> int (*signctx) (EVP_PKEY_CTX *ctx,
> unsigned char *sig,
> size_t *siglen,
> EVP_MD_CTX *mctx));
>
>void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth,
> int (*verifyctx_init) (EVP_PKEY_CTX *ctx,
> EVP_MD_CTX *mctx),
> int (*verifyctx) (EVP_PKEY_CTX *ctx,
> const unsigned char *sig,
> int siglen,
> EVP_MD_CTX *mctx));
>
>void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth,
> int (*encrypt_init) (EVP_PKEY_CTX *ctx),
> int (*encryptfn) (EVP_PKEY_CTX *ctx,
> unsigned char *out,
> size_t *outlen,
> const unsigned char *in,
> size_t inlen));
>
>void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth,
> int (*decrypt_init) (EVP_PKEY_CTX *ctx),
> int (*decrypt) (EVP_PKEY_CTX *ctx,
> unsigned char *out,
> size_t *outlen,
> const unsigned char *in,
> size_t inlen));
>
>void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth,
> int (*derive_init) (EVP_PKEY_CTX *ctx),
> int (*derive) (EVP_PKEY_CTX *ctx,
> unsigned char *key,
> size_t *keylen));
>
>void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth,
> int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
> void *p2),
> int (*ctrl_str) (EVP_PKEY_CTX *ctx,
> const char *type,
> const char *value));
>
>void EVP_PKEY_meth_get_init(EVP_PKEY_METHOD *pmeth,
> int (**pinit) (EVP_PKEY_CTX *ctx));
>
>void EVP_PKEY_meth_get_copy(EVP_PKEY_METHOD *pmeth,
> int (**pcopy) (EVP_PKEY_CTX *dst,
> EVP_PKEY_CTX *src));
>
>void EVP_PKEY_meth_get_cleanup(EVP_PKEY_METHOD *pmeth,
> void (**pcleanup) (EVP_PKEY_CTX *ctx));
>
>void EVP_PKEY_meth_get_paramgen(EVP_PKEY_METHOD *pmeth,
> int (**pparamgen_init) (EVP_PKEY_CTX *ctx),
> int (**pparamgen) (EVP_PKEY_CTX *ctx,
> EVP_PKEY *pkey));
>
>void EVP_PKEY_meth_get_keygen(EVP_PKEY_METHOD *pmeth,
> int (**pkeygen_init) (EVP_PKEY_CTX *ctx),
> int (**pkeygen) (EVP_PKEY_CTX *ctx,
> EVP_PKEY *pkey));
>
>void EVP_PKEY_meth_get_sign(EVP_PKEY_METHOD *pmeth,
> int (**psign_init) (EVP_PKEY_CTX *ctx),
> int (**psign) (EVP_PKEY_CTX *ctx,
> unsigned char *sig, size_t *siglen,
> const unsigned char *tbs,
> size_t tbslen));
>
>void EVP_PKEY_meth_get_verify(EVP_PKEY_METHOD *pmeth,
> int (**pverify_init) (EVP_PKEY_CTX *ctx),
> int (**pverify) (EVP_PKEY_CTX *ctx,
> const unsigned char *sig,
> size_t siglen,
> const unsigned char *tbs,
> size_t tbslen));
>
>void EVP_PKEY_meth_get_verify_recover(EVP_PKEY_METHOD *pmeth,
> int (**pverify_recover_init) (EVP_PKEY_CTX
> *ctx),
> int (**pverify_recover) (EVP_PKEY_CTX
> *ctx,
> unsigned char
> *sig,
> size_t *siglen,
> const unsigned
> char *tbs,
> size_t tbslen));
>
>void EVP_PKEY_meth_get_signctx(EVP_PKEY_METHOD *pmeth,
> int (**psignctx_init) (EVP_PKEY_CTX *ctx,
> EVP_MD_CTX *mctx),
> int (**psignctx) (EVP_PKEY_CTX *ctx,
> unsigned char *sig,
> size_t *siglen,
> EVP_MD_CTX *mctx));
>
>void EVP_PKEY_meth_get_verifyctx(EVP_PKEY_METHOD *pmeth,
> int (**pverifyctx_init) (EVP_PKEY_CTX *ctx,
> EVP_MD_CTX *mctx),
> int (**pverifyctx) (EVP_PKEY_CTX *ctx,
> const unsigned char *sig,
> int siglen,
> EVP_MD_CTX *mctx));
>
>void EVP_PKEY_meth_get_encrypt(EVP_PKEY_METHOD *pmeth,
> int (**pencrypt_init) (EVP_PKEY_CTX *ctx),
> int (**pencryptfn) (EVP_PKEY_CTX *ctx,
> unsigned char *out,
> size_t *outlen,
> const unsigned char *in,
> size_t inlen));
>
>void EVP_PKEY_meth_get_decrypt(EVP_PKEY_METHOD *pmeth,
> int (**pdecrypt_init) (EVP_PKEY_CTX *ctx),
> int (**pdecrypt) (EVP_PKEY_CTX *ctx,
> unsigned char *out,
> size_t *outlen,
> const unsigned char *in,
> size_t inlen));
>
>void EVP_PKEY_meth_get_derive(EVP_PKEY_METHOD *pmeth,
> int (**pderive_init) (EVP_PKEY_CTX *ctx),
> int (**pderive) (EVP_PKEY_CTX *ctx,
> unsigned char *key,
> size_t *keylen));
>
>void EVP_PKEY_meth_get_ctrl(EVP_PKEY_METHOD *pmeth,
> int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1,
> void *p2),
> int (**pctrl_str) (EVP_PKEY_CTX *ctx,
> const char *type,
> const char *value));
>
>void EVP_add_alg_module(void);
>
>
>
>
>
>
>
>int ERR_load_EVP_strings(void);
># 1598 "/usr/include/openssl/evp.h" 3 4
>}
># 24 "/usr/include/openssl/x509.h" 2 3 4
>
>
>
>
># 1 "/usr/include/openssl/ec.h" 1 3 4
># 27 "/usr/include/openssl/ec.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 28 "/usr/include/openssl/ec.h" 2 3 4
># 36 "/usr/include/openssl/ec.h" 3 4
>extern "C" {
># 45 "/usr/include/openssl/ec.h" 3 4
>typedef enum {
>
>
> POINT_CONVERSION_COMPRESSED = 2,
>
> POINT_CONVERSION_UNCOMPRESSED = 4,
>
>
> POINT_CONVERSION_HYBRID = 6
>} point_conversion_form_t;
>
>typedef struct ec_method_st EC_METHOD;
>typedef struct ec_group_st EC_GROUP;
>typedef struct ec_point_st EC_POINT;
>typedef struct ecpk_parameters_st ECPKPARAMETERS;
>typedef struct ec_parameters_st ECPARAMETERS;
># 70 "/usr/include/openssl/ec.h" 3 4
>const EC_METHOD *EC_GFp_simple_method(void);
>
>
>
>
>const EC_METHOD *EC_GFp_mont_method(void);
>
>
>
>
>const EC_METHOD *EC_GFp_nist_method(void);
>
>
>
>
>
>const EC_METHOD *EC_GFp_nistp224_method(void);
>
>
>
>
>const EC_METHOD *EC_GFp_nistp256_method(void);
>
>
>
>
>const EC_METHOD *EC_GFp_nistp521_method(void);
># 119 "/usr/include/openssl/ec.h" 3 4
>EC_GROUP *EC_GROUP_new(const EC_METHOD *meth);
>
>
>
>
>void EC_GROUP_free(EC_GROUP *group);
>
>
>
>
>void EC_GROUP_clear_free(EC_GROUP *group);
>
>
>
>
>
>
>int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src);
>
>
>
>
>
>
>EC_GROUP *EC_GROUP_dup(const EC_GROUP *src);
>
>
>
>
>
>const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group);
>
>
>
>
>
>int EC_METHOD_get_field_type(const EC_METHOD *meth);
># 165 "/usr/include/openssl/ec.h" 3 4
>int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
> const BIGNUM *order, const BIGNUM *cofactor);
>
>
>
>
>
>const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group);
>
>
>
>
>
>BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group);
>
>
>
>
>
>
>
>int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx);
>
>
>
>
>
>const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group);
>
>
>
>
>
>int EC_GROUP_order_bits(const EC_GROUP *group);
>
>
>
>
>
>
>
>int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
> BN_CTX *ctx);
>
>
>
>
>
>const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group);
>
>
>
>
>
>void EC_GROUP_set_curve_name(EC_GROUP *group, int nid);
>
>
>
>
>
>int EC_GROUP_get_curve_name(const EC_GROUP *group);
>
>void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag);
>int EC_GROUP_get_asn1_flag(const EC_GROUP *group);
>
>void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
> point_conversion_form_t form);
>point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *);
>
>unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x);
>size_t EC_GROUP_get_seed_len(const EC_GROUP *);
>size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len);
># 246 "/usr/include/openssl/ec.h" 3 4
>int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
> const BIGNUM *b, BN_CTX *ctx);
># 257 "/usr/include/openssl/ec.h" 3 4
>int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a,
> BIGNUM *b, BN_CTX *ctx);
># 287 "/usr/include/openssl/ec.h" 3 4
>int EC_GROUP_get_degree(const EC_GROUP *group);
>
>
>
>
>
>
>int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx);
>
>
>
>
>
>
>int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx);
>
>
>
>
>
>
>
>int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx);
># 324 "/usr/include/openssl/ec.h" 3 4
>EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a,
> const BIGNUM *b, BN_CTX *ctx);
># 344 "/usr/include/openssl/ec.h" 3 4
>EC_GROUP *EC_GROUP_new_by_curve_name(int nid);
>
>
>
>
>
>
>EC_GROUP *EC_GROUP_new_from_ecparameters(const ECPARAMETERS *params);
>
>
>
>
>
>
>
>ECPARAMETERS *EC_GROUP_get_ecparameters(const EC_GROUP *group,
> ECPARAMETERS *params);
>
>
>
>
>
>
>EC_GROUP *EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS *params);
>
>
>
>
>
>
>
>ECPKPARAMETERS *EC_GROUP_get_ecpkparameters(const EC_GROUP *group,
> ECPKPARAMETERS *params);
>
>
>
>
>
>typedef struct {
> int nid;
> const char *comment;
>} EC_builtin_curve;
>
>
>
>
>
>
>
>size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems);
>
>const char *EC_curve_nid2nist(int nid);
>int EC_curve_nist2nid(const char *name);
># 406 "/usr/include/openssl/ec.h" 3 4
>EC_POINT *EC_POINT_new(const EC_GROUP *group);
>
>
>
>
>void EC_POINT_free(EC_POINT *point);
>
>
>
>
>void EC_POINT_clear_free(EC_POINT *point);
>
>
>
>
>
>
>int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src);
>
>
>
>
>
>
>
>EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group);
>
>
>
>
>
>const EC_METHOD *EC_POINT_method_of(const EC_POINT *point);
>
>
>
>
>
>
>int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point);
># 455 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group,
> EC_POINT *p, const BIGNUM *x,
> const BIGNUM *y, const BIGNUM *z,
> BN_CTX *ctx);
># 469 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
> const EC_POINT *p, BIGNUM *x,
> BIGNUM *y, BIGNUM *z,
> BN_CTX *ctx);
># 482 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *p,
> const BIGNUM *x, const BIGNUM *y,
> BN_CTX *ctx);
># 494 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
> const EC_POINT *p, BIGNUM *x,
> BIGNUM *y, BN_CTX *ctx);
># 506 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group,
> EC_POINT *p, const BIGNUM *x,
> int y_bit, BN_CTX *ctx);
># 556 "/usr/include/openssl/ec.h" 3 4
>size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p,
> point_conversion_form_t form,
> unsigned char *buf, size_t len, BN_CTX *ctx);
># 568 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p,
> const unsigned char *buf, size_t len, BN_CTX *ctx);
># 579 "/usr/include/openssl/ec.h" 3 4
>size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point,
> point_conversion_form_t form,
> unsigned char **pbuf, BN_CTX *ctx);
>
>
>BIGNUM *EC_POINT_point2bn(const EC_GROUP *, const EC_POINT *,
> point_conversion_form_t form, BIGNUM *, BN_CTX *);
>EC_POINT *EC_POINT_bn2point(const EC_GROUP *, const BIGNUM *,
> EC_POINT *, BN_CTX *);
>char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *,
> point_conversion_form_t form, BN_CTX *);
>EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *,
> EC_POINT *, BN_CTX *);
># 605 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
> const EC_POINT *b, BN_CTX *ctx);
># 615 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
> BN_CTX *ctx);
>
>
>
>
>
>
>
>int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx);
>
>
>
>
>
>
>int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p);
>
>
>
>
>
>
>
>int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
> BN_CTX *ctx);
># 649 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
> BN_CTX *ctx);
>
>int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx);
>int EC_POINTs_make_affine(const EC_GROUP *group, size_t num,
> EC_POINT *points[], BN_CTX *ctx);
># 666 "/usr/include/openssl/ec.h" 3 4
>int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n,
> size_t num, const EC_POINT *p[], const BIGNUM *m[],
> BN_CTX *ctx);
># 679 "/usr/include/openssl/ec.h" 3 4
>int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n,
> const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx);
>
>
>
>
>
>
>int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx);
>
>
>
>
>
>int EC_GROUP_have_precompute_mult(const EC_GROUP *group);
>
>
>
>
>
>extern const ASN1_ITEM ECPKPARAMETERS_it;
>ECPKPARAMETERS *ECPKPARAMETERS_new(void); void ECPKPARAMETERS_free(ECPKPARAMETERS *a);
>extern const ASN1_ITEM ECPARAMETERS_it;
>ECPARAMETERS *ECPARAMETERS_new(void); void ECPARAMETERS_free(ECPARAMETERS *a);
>
>
>
>
>
>int EC_GROUP_get_basis_type(const EC_GROUP *);
># 718 "/usr/include/openssl/ec.h" 3 4
>EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len);
>int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out);
># 728 "/usr/include/openssl/ec.h" 3 4
>int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off);
>
>int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off);
># 749 "/usr/include/openssl/ec.h" 3 4
>EC_KEY *EC_KEY_new(void);
>
>int EC_KEY_get_flags(const EC_KEY *key);
>
>void EC_KEY_set_flags(EC_KEY *key, int flags);
>
>void EC_KEY_clear_flags(EC_KEY *key, int flags);
>
>
>
>
>
>
>EC_KEY *EC_KEY_new_by_curve_name(int nid);
>
>
>
>
>void EC_KEY_free(EC_KEY *key);
>
>
>
>
>
>
>EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src);
>
>
>
>
>
>EC_KEY *EC_KEY_dup(const EC_KEY *src);
>
>
>
>
>
>int EC_KEY_up_ref(EC_KEY *key);
>
>
>
>
>
>const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key);
>
>
>
>
>
>
>
>int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group);
>
>
>
>
>
>const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key);
>
>
>
>
>
>
>
>int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv);
>
>
>
>
>
>const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key);
>
>
>
>
>
>
>
>int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub);
>
>unsigned EC_KEY_get_enc_flags(const EC_KEY *key);
>void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags);
>point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key);
>void EC_KEY_set_conv_form(EC_KEY *eckey, point_conversion_form_t cform);
>
>
>
>int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg);
>void *EC_KEY_get_ex_data(const EC_KEY *key, int idx);
>
>
>void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag);
>
>
>
>
>
>
>
>int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx);
>
>
>
>
>
>int EC_KEY_generate_key(EC_KEY *key);
>
>
>
>
>
>int EC_KEY_check_key(const EC_KEY *key);
>
>
>
>
>
>int EC_KEY_can_sign(const EC_KEY *eckey);
># 876 "/usr/include/openssl/ec.h" 3 4
>int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x,
> BIGNUM *y);
># 886 "/usr/include/openssl/ec.h" 3 4
>size_t EC_KEY_key2buf(const EC_KEY *key, point_conversion_form_t form,
> unsigned char **pbuf, BN_CTX *ctx);
># 897 "/usr/include/openssl/ec.h" 3 4
>int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf, size_t len,
> BN_CTX *ctx);
># 907 "/usr/include/openssl/ec.h" 3 4
>int EC_KEY_oct2priv(EC_KEY *key, const unsigned char *buf, size_t len);
># 917 "/usr/include/openssl/ec.h" 3 4
>size_t EC_KEY_priv2oct(const EC_KEY *key, unsigned char *buf, size_t len);
>
>
>
>
>
>
>size_t EC_KEY_priv2buf(const EC_KEY *eckey, unsigned char **pbuf);
># 936 "/usr/include/openssl/ec.h" 3 4
>EC_KEY *d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len);
>
>
>
>
>
>
>
>int i2d_ECPrivateKey(EC_KEY *key, unsigned char **out);
># 957 "/usr/include/openssl/ec.h" 3 4
>EC_KEY *d2i_ECParameters(EC_KEY **key, const unsigned char **in, long len);
>
>
>
>
>
>
>
>int i2d_ECParameters(EC_KEY *key, unsigned char **out);
># 979 "/usr/include/openssl/ec.h" 3 4
>EC_KEY *o2i_ECPublicKey(EC_KEY **key, const unsigned char **in, long len);
>
>
>
>
>
>
>
>int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out);
>
>
>
>
>
>
>int ECParameters_print(BIO *bp, const EC_KEY *key);
>
>
>
>
>
>
>
>int EC_KEY_print(BIO *bp, const EC_KEY *key, int off);
>
>
>
>
>
>
>
>int ECParameters_print_fp(FILE *fp, const EC_KEY *key);
>
>
>
>
>
>
>
>int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off);
>
>
>
>const EC_KEY_METHOD *EC_KEY_OpenSSL(void);
>const EC_KEY_METHOD *EC_KEY_get_default_method(void);
>void EC_KEY_set_default_method(const EC_KEY_METHOD *meth);
>const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key);
>int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth);
>EC_KEY *EC_KEY_new_method(ENGINE *engine);
>
>int ECDH_KDF_X9_62(unsigned char *out, size_t outlen,
> const unsigned char *Z, size_t Zlen,
> const unsigned char *sinfo, size_t sinfolen,
> const EVP_MD *md);
>
>int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key,
> const EC_KEY *ecdh,
> void *(*KDF) (const void *in, size_t inlen,
> void *out, size_t *outlen));
>
>typedef struct ECDSA_SIG_st ECDSA_SIG;
>
>
>
>
>ECDSA_SIG *ECDSA_SIG_new(void);
>
>
>
>
>void ECDSA_SIG_free(ECDSA_SIG *sig);
>
>
>
>
>
>
>
>int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
># 1066 "/usr/include/openssl/ec.h" 3 4
>ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len);
>
>
>
>
>
>
>void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
>
>
>
>
>
>
>int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s);
># 1089 "/usr/include/openssl/ec.h" 3 4
>ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
> EC_KEY *eckey);
># 1102 "/usr/include/openssl/ec.h" 3 4
>ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
> const BIGNUM *kinv, const BIGNUM *rp,
> EC_KEY *eckey);
># 1115 "/usr/include/openssl/ec.h" 3 4
>int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
> const ECDSA_SIG *sig, EC_KEY *eckey);
># 1125 "/usr/include/openssl/ec.h" 3 4
>int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp);
># 1137 "/usr/include/openssl/ec.h" 3 4
>int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen,
> unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
># 1153 "/usr/include/openssl/ec.h" 3 4
>int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen,
> unsigned char *sig, unsigned int *siglen,
> const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey);
># 1168 "/usr/include/openssl/ec.h" 3 4
>int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen,
> const unsigned char *sig, int siglen, EC_KEY *eckey);
>
>
>
>
>
>int ECDSA_size(const EC_KEY *eckey);
>
>
>
>
>
>EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth);
>void EC_KEY_METHOD_free(EC_KEY_METHOD *meth);
>void EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth,
> int (*init)(EC_KEY *key),
> void (*finish)(EC_KEY *key),
> int (*copy)(EC_KEY *dest, const EC_KEY *src),
> int (*set_group)(EC_KEY *key, const EC_GROUP *grp),
> int (*set_private)(EC_KEY *key,
> const BIGNUM *priv_key),
> int (*set_public)(EC_KEY *key,
> const EC_POINT *pub_key));
>
>void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth,
> int (*keygen)(EC_KEY *key));
>
>void EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth,
> int (*ckey)(unsigned char **psec,
> size_t *pseclen,
> const EC_POINT *pub_key,
> const EC_KEY *ecdh));
>
>void EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth,
> int (*sign)(int type, const unsigned char *dgst,
> int dlen, unsigned char *sig,
> unsigned int *siglen,
> const BIGNUM *kinv, const BIGNUM *r,
> EC_KEY *eckey),
> int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
> BIGNUM **kinvp, BIGNUM **rp),
> ECDSA_SIG *(*sign_sig)(const unsigned char *dgst,
> int dgst_len,
> const BIGNUM *in_kinv,
> const BIGNUM *in_r,
> EC_KEY *eckey));
>
>void EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth,
> int (*verify)(int type, const unsigned
> char *dgst, int dgst_len,
> const unsigned char *sigbuf,
> int sig_len, EC_KEY *eckey),
> int (*verify_sig)(const unsigned char *dgst,
> int dgst_len,
> const ECDSA_SIG *sig,
> EC_KEY *eckey));
>
>void EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth,
> int (**pinit)(EC_KEY *key),
> void (**pfinish)(EC_KEY *key),
> int (**pcopy)(EC_KEY *dest, const EC_KEY *src),
> int (**pset_group)(EC_KEY *key,
> const EC_GROUP *grp),
> int (**pset_private)(EC_KEY *key,
> const BIGNUM *priv_key),
> int (**pset_public)(EC_KEY *key,
> const EC_POINT *pub_key));
>
>void EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth,
> int (**pkeygen)(EC_KEY *key));
>
>void EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth,
> int (**pck)(unsigned char **psec,
> size_t *pseclen,
> const EC_POINT *pub_key,
> const EC_KEY *ecdh));
>
>void EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth,
> int (**psign)(int type, const unsigned char *dgst,
> int dlen, unsigned char *sig,
> unsigned int *siglen,
> const BIGNUM *kinv, const BIGNUM *r,
> EC_KEY *eckey),
> int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in,
> BIGNUM **kinvp, BIGNUM **rp),
> ECDSA_SIG *(**psign_sig)(const unsigned char *dgst,
> int dgst_len,
> const BIGNUM *in_kinv,
> const BIGNUM *in_r,
> EC_KEY *eckey));
>
>void EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth,
> int (**pverify)(int type, const unsigned
> char *dgst, int dgst_len,
> const unsigned char *sigbuf,
> int sig_len, EC_KEY *eckey),
> int (**pverify_sig)(const unsigned char *dgst,
> int dgst_len,
> const ECDSA_SIG *sig,
> EC_KEY *eckey));
># 1360 "/usr/include/openssl/ec.h" 3 4
>int ERR_load_EC_strings(void);
># 1573 "/usr/include/openssl/ec.h" 3 4
>}
># 29 "/usr/include/openssl/x509.h" 2 3 4
>
>
># 1 "/usr/include/openssl/rsa.h" 1 3 4
># 13 "/usr/include/openssl/rsa.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/rsa.h" 2 3 4
># 24 "/usr/include/openssl/rsa.h" 3 4
>extern "C" {
># 172 "/usr/include/openssl/rsa.h" 3 4
>RSA *RSA_new(void);
>RSA *RSA_new_method(ENGINE *engine);
>int RSA_bits(const RSA *rsa);
>int RSA_size(const RSA *rsa);
>int RSA_security_bits(const RSA *rsa);
>
>int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
>int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q);
>int RSA_set0_crt_params(RSA *r,BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp);
>void RSA_get0_key(const RSA *r,
> const BIGNUM **n, const BIGNUM **e, const BIGNUM **d);
>void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q);
>void RSA_get0_crt_params(const RSA *r,
> const BIGNUM **dmp1, const BIGNUM **dmq1,
> const BIGNUM **iqmp);
>void RSA_clear_flags(RSA *r, int flags);
>int RSA_test_flags(const RSA *r, int flags);
>void RSA_set_flags(RSA *r, int flags);
>ENGINE *RSA_get0_engine(const RSA *r);
>
>
>RSA *RSA_generate_key(int bits, unsigned long e, void (*callback) (int, int, void *), void *cb_arg) __attribute__ ((deprecated));
>
>
>
>
>int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
>
>int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2, BIGNUM *q1,
> BIGNUM *q2, const BIGNUM *Xp1, const BIGNUM *Xp2,
> const BIGNUM *Xp, const BIGNUM *Xq1, const BIGNUM *Xq2,
> const BIGNUM *Xq, const BIGNUM *e, BN_GENCB *cb);
>int RSA_X931_generate_key_ex(RSA *rsa, int bits, const BIGNUM *e,
> BN_GENCB *cb);
>
>int RSA_check_key(const RSA *);
>int RSA_check_key_ex(const RSA *, BN_GENCB *cb);
>
>int RSA_public_encrypt(int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_private_encrypt(int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_public_decrypt(int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_private_decrypt(int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>void RSA_free(RSA *r);
>
>int RSA_up_ref(RSA *r);
>
>int RSA_flags(const RSA *r);
>
>void RSA_set_default_method(const RSA_METHOD *meth);
>const RSA_METHOD *RSA_get_default_method(void);
>const RSA_METHOD *RSA_get_method(const RSA *rsa);
>int RSA_set_method(RSA *rsa, const RSA_METHOD *meth);
>
>
>const RSA_METHOD *RSA_PKCS1_OpenSSL(void);
>
>const RSA_METHOD *RSA_null_method(void);
>
>RSA *d2i_RSAPublicKey(RSA **a, const unsigned char **in, long len); int i2d_RSAPublicKey(const RSA *a, unsigned char **out); extern const ASN1_ITEM RSAPublicKey_it;
>RSA *d2i_RSAPrivateKey(RSA **a, const unsigned char **in, long len); int i2d_RSAPrivateKey(const RSA *a, unsigned char **out); extern const ASN1_ITEM RSAPrivateKey_it;
>
>typedef struct rsa_pss_params_st {
> X509_ALGOR *hashAlgorithm;
> X509_ALGOR *maskGenAlgorithm;
> ASN1_INTEGER *saltLength;
> ASN1_INTEGER *trailerField;
>} RSA_PSS_PARAMS;
>
>RSA_PSS_PARAMS *RSA_PSS_PARAMS_new(void); void RSA_PSS_PARAMS_free(RSA_PSS_PARAMS *a); RSA_PSS_PARAMS *d2i_RSA_PSS_PARAMS(RSA_PSS_PARAMS **a, const unsigned char **in, long len); int i2d_RSA_PSS_PARAMS(RSA_PSS_PARAMS *a, unsigned char **out); extern const ASN1_ITEM RSA_PSS_PARAMS_it;
>
>typedef struct rsa_oaep_params_st {
> X509_ALGOR *hashFunc;
> X509_ALGOR *maskGenFunc;
> X509_ALGOR *pSourceFunc;
>} RSA_OAEP_PARAMS;
>
>RSA_OAEP_PARAMS *RSA_OAEP_PARAMS_new(void); void RSA_OAEP_PARAMS_free(RSA_OAEP_PARAMS *a); RSA_OAEP_PARAMS *d2i_RSA_OAEP_PARAMS(RSA_OAEP_PARAMS **a, const unsigned char **in, long len); int i2d_RSA_OAEP_PARAMS(RSA_OAEP_PARAMS *a, unsigned char **out); extern const ASN1_ITEM RSA_OAEP_PARAMS_it;
>
>
>int RSA_print_fp(FILE *fp, const RSA *r, int offset);
>
>
>int RSA_print(BIO *bp, const RSA *r, int offset);
>
>
>
>
>
>int RSA_sign(int type, const unsigned char *m, unsigned int m_length,
> unsigned char *sigret, unsigned int *siglen, RSA *rsa);
>int RSA_verify(int type, const unsigned char *m, unsigned int m_length,
> const unsigned char *sigbuf, unsigned int siglen, RSA *rsa);
>
>
>
>
>
>int RSA_sign_ASN1_OCTET_STRING(int type,
> const unsigned char *m, unsigned int m_length,
> unsigned char *sigret, unsigned int *siglen,
> RSA *rsa);
>int RSA_verify_ASN1_OCTET_STRING(int type, const unsigned char *m,
> unsigned int m_length, unsigned char *sigbuf,
> unsigned int siglen, RSA *rsa);
>
>int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);
>void RSA_blinding_off(RSA *rsa);
>BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx);
>
>int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen,
> const unsigned char *f, int fl);
>int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen,
> const unsigned char *f, int fl,
> int rsa_len);
>int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen,
> const unsigned char *f, int fl);
>int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen,
> const unsigned char *f, int fl,
> int rsa_len);
>int PKCS1_MGF1(unsigned char *mask, long len, const unsigned char *seed,
> long seedlen, const EVP_MD *dgst);
>int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
> const unsigned char *f, int fl,
> const unsigned char *p, int pl);
>int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
> const unsigned char *f, int fl, int rsa_len,
> const unsigned char *p, int pl);
>int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
> const unsigned char *from, int flen,
> const unsigned char *param, int plen,
> const EVP_MD *md, const EVP_MD *mgf1md);
>int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen,
> const unsigned char *from, int flen,
> int num, const unsigned char *param,
> int plen, const EVP_MD *md,
> const EVP_MD *mgf1md);
>int RSA_padding_add_SSLv23(unsigned char *to, int tlen,
> const unsigned char *f, int fl);
>int RSA_padding_check_SSLv23(unsigned char *to, int tlen,
> const unsigned char *f, int fl, int rsa_len);
>int RSA_padding_add_none(unsigned char *to, int tlen, const unsigned char *f,
> int fl);
>int RSA_padding_check_none(unsigned char *to, int tlen,
> const unsigned char *f, int fl, int rsa_len);
>int RSA_padding_add_X931(unsigned char *to, int tlen, const unsigned char *f,
> int fl);
>int RSA_padding_check_X931(unsigned char *to, int tlen,
> const unsigned char *f, int fl, int rsa_len);
>int RSA_X931_hash_id(int nid);
>
>int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash,
> const EVP_MD *Hash, const unsigned char *EM,
> int sLen);
>int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM,
> const unsigned char *mHash, const EVP_MD *Hash,
> int sLen);
>
>int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash,
> const EVP_MD *Hash, const EVP_MD *mgf1Hash,
> const unsigned char *EM, int sLen);
>
>int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM,
> const unsigned char *mHash,
> const EVP_MD *Hash, const EVP_MD *mgf1Hash,
> int sLen);
>
>
>
>int RSA_set_ex_data(RSA *r, int idx, void *arg);
>void *RSA_get_ex_data(const RSA *r, int idx);
>
>RSA *RSAPublicKey_dup(RSA *rsa);
>RSA *RSAPrivateKey_dup(RSA *rsa);
># 372 "/usr/include/openssl/rsa.h" 3 4
>RSA_METHOD *RSA_meth_new(const char *name, int flags);
>void RSA_meth_free(RSA_METHOD *meth);
>RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth);
>const char *RSA_meth_get0_name(const RSA_METHOD *meth);
>int RSA_meth_set1_name(RSA_METHOD *meth, const char *name);
>int RSA_meth_get_flags(RSA_METHOD *meth);
>int RSA_meth_set_flags(RSA_METHOD *meth, int flags);
>void *RSA_meth_get0_app_data(const RSA_METHOD *meth);
>int RSA_meth_set0_app_data(RSA_METHOD *meth, void *app_data);
>int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth))
> (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_meth_set_pub_enc(RSA_METHOD *rsa,
> int (*pub_enc) (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa,
> int padding));
>int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth))
> (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_meth_set_pub_dec(RSA_METHOD *rsa,
> int (*pub_dec) (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa,
> int padding));
>int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth))
> (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_meth_set_priv_enc(RSA_METHOD *rsa,
> int (*priv_enc) (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa,
> int padding));
>int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth))
> (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa, int padding);
>int RSA_meth_set_priv_dec(RSA_METHOD *rsa,
> int (*priv_dec) (int flen, const unsigned char *from,
> unsigned char *to, RSA *rsa,
> int padding));
>int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth))
> (BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx);
>int RSA_meth_set_mod_exp(RSA_METHOD *rsa,
> int (*mod_exp) (BIGNUM *r0, const BIGNUM *I, RSA *rsa,
> BN_CTX *ctx));
>int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth))
> (BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
> const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
>int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa,
> int (*bn_mod_exp) (BIGNUM *r,
> const BIGNUM *a,
> const BIGNUM *p,
> const BIGNUM *m,
> BN_CTX *ctx,
> BN_MONT_CTX *m_ctx));
>int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa);
>int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa));
>int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa);
>int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa));
>int (*RSA_meth_get_sign(const RSA_METHOD *meth))
> (int type,
> const unsigned char *m, unsigned int m_length,
> unsigned char *sigret, unsigned int *siglen,
> const RSA *rsa);
>int RSA_meth_set_sign(RSA_METHOD *rsa,
> int (*sign) (int type, const unsigned char *m,
> unsigned int m_length,
> unsigned char *sigret, unsigned int *siglen,
> const RSA *rsa));
>int (*RSA_meth_get_verify(const RSA_METHOD *meth))
> (int dtype, const unsigned char *m,
> unsigned int m_length, const unsigned char *sigbuf,
> unsigned int siglen, const RSA *rsa);
>int RSA_meth_set_verify(RSA_METHOD *rsa,
> int (*verify) (int dtype, const unsigned char *m,
> unsigned int m_length,
> const unsigned char *sigbuf,
> unsigned int siglen, const RSA *rsa));
>int (*RSA_meth_get_keygen(const RSA_METHOD *meth))
> (RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb);
>int RSA_meth_set_keygen(RSA_METHOD *rsa,
> int (*keygen) (RSA *rsa, int bits, BIGNUM *e,
> BN_GENCB *cb));
>
>
>
>
>
>
>
>int ERR_load_RSA_strings(void);
># 597 "/usr/include/openssl/rsa.h" 3 4
>}
># 32 "/usr/include/openssl/x509.h" 2 3 4
># 1 "/usr/include/openssl/dsa.h" 1 3 4
># 18 "/usr/include/openssl/dsa.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 19 "/usr/include/openssl/dsa.h" 2 3 4
>
>
>
>extern "C" {
>
>
>
>
>
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 29 "/usr/include/openssl/dsa.h" 2 3 4
>
>
># 1 "/usr/include/openssl/dh.h" 1 3 4
># 13 "/usr/include/openssl/dh.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/dh.h" 2 3 4
># 25 "/usr/include/openssl/dh.h" 3 4
>extern "C" {
># 65 "/usr/include/openssl/dh.h" 3 4
>extern const ASN1_ITEM DHparams_it;
># 115 "/usr/include/openssl/dh.h" 3 4
>DH *DHparams_dup(DH *);
>
>const DH_METHOD *DH_OpenSSL(void);
>
>void DH_set_default_method(const DH_METHOD *meth);
>const DH_METHOD *DH_get_default_method(void);
>int DH_set_method(DH *dh, const DH_METHOD *meth);
>DH *DH_new_method(ENGINE *engine);
>
>DH *DH_new(void);
>void DH_free(DH *dh);
>int DH_up_ref(DH *dh);
>int DH_bits(const DH *dh);
>int DH_size(const DH *dh);
>int DH_security_bits(const DH *dh);
>
>
>int DH_set_ex_data(DH *d, int idx, void *arg);
>void *DH_get_ex_data(DH *d, int idx);
>
>
>DH *DH_generate_parameters(int prime_len, int generator, void (*callback) (int, int, void *), void *cb_arg) __attribute__ ((deprecated));
>
>
>
>
>
>int DH_generate_parameters_ex(DH *dh, int prime_len, int generator,
> BN_GENCB *cb);
>
>int DH_check_params(const DH *dh, int *ret);
>int DH_check(const DH *dh, int *codes);
>int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key, int *codes);
>int DH_generate_key(DH *dh);
>int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh);
>int DH_compute_key_padded(unsigned char *key, const BIGNUM *pub_key, DH *dh);
>DH *d2i_DHparams(DH **a, const unsigned char **pp, long length);
>int i2d_DHparams(const DH *a, unsigned char **pp);
>DH *d2i_DHxparams(DH **a, const unsigned char **pp, long length);
>int i2d_DHxparams(const DH *a, unsigned char **pp);
>
>int DHparams_print_fp(FILE *fp, const DH *x);
>
>int DHparams_print(BIO *bp, const DH *x);
>
>
>DH *DH_get_1024_160(void);
>DH *DH_get_2048_224(void);
>DH *DH_get_2048_256(void);
>
>
>
>int DH_KDF_X9_42(unsigned char *out, size_t outlen,
> const unsigned char *Z, size_t Zlen,
> ASN1_OBJECT *key_oid,
> const unsigned char *ukm, size_t ukmlen, const EVP_MD *md);
>
>
>void DH_get0_pqg(const DH *dh,
> const BIGNUM **p, const BIGNUM **q, const BIGNUM **g);
>int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g);
>void DH_get0_key(const DH *dh,
> const BIGNUM **pub_key, const BIGNUM **priv_key);
>int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key);
>void DH_clear_flags(DH *dh, int flags);
>int DH_test_flags(const DH *dh, int flags);
>void DH_set_flags(DH *dh, int flags);
>ENGINE *DH_get0_engine(DH *d);
>long DH_get_length(const DH *dh);
>int DH_set_length(DH *dh, long length);
>
>DH_METHOD *DH_meth_new(const char *name, int flags);
>void DH_meth_free(DH_METHOD *dhm);
>DH_METHOD *DH_meth_dup(const DH_METHOD *dhm);
>const char *DH_meth_get0_name(const DH_METHOD *dhm);
>int DH_meth_set1_name(DH_METHOD *dhm, const char *name);
>int DH_meth_get_flags(DH_METHOD *dhm);
>int DH_meth_set_flags(DH_METHOD *dhm, int flags);
>void *DH_meth_get0_app_data(const DH_METHOD *dhm);
>int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data);
>int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *);
>int DH_meth_set_generate_key(DH_METHOD *dhm, int (*generate_key) (DH *));
>int (*DH_meth_get_compute_key(const DH_METHOD *dhm))
> (unsigned char *key, const BIGNUM *pub_key, DH *dh);
>int DH_meth_set_compute_key(DH_METHOD *dhm,
> int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh));
>int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm))
> (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
> BN_CTX *, BN_MONT_CTX *);
>int DH_meth_set_bn_mod_exp(DH_METHOD *dhm,
> int (*bn_mod_exp) (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *,
> const BIGNUM *, BN_CTX *, BN_MONT_CTX *));
>int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *);
>int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *));
>int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *);
>int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *));
>int (*DH_meth_get_generate_params(const DH_METHOD *dhm))
> (DH *, int, int, BN_GENCB *);
>int DH_meth_set_generate_params(DH_METHOD *dhm,
> int (*generate_params) (DH *, int, int, BN_GENCB *));
># 318 "/usr/include/openssl/dh.h" 3 4
>int ERR_load_DH_strings(void);
># 364 "/usr/include/openssl/dh.h" 3 4
>}
># 32 "/usr/include/openssl/dsa.h" 2 3 4
># 71 "/usr/include/openssl/dsa.h" 3 4
>typedef struct DSA_SIG_st DSA_SIG;
># 80 "/usr/include/openssl/dsa.h" 3 4
>DSA *DSAparams_dup(DSA *x);
>DSA_SIG *DSA_SIG_new(void);
>void DSA_SIG_free(DSA_SIG *a);
>int i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp);
>DSA_SIG *d2i_DSA_SIG(DSA_SIG **v, const unsigned char **pp, long length);
>void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps);
>int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s);
>
>DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa);
>int DSA_do_verify(const unsigned char *dgst, int dgst_len,
> DSA_SIG *sig, DSA *dsa);
>
>const DSA_METHOD *DSA_OpenSSL(void);
>
>void DSA_set_default_method(const DSA_METHOD *);
>const DSA_METHOD *DSA_get_default_method(void);
>int DSA_set_method(DSA *dsa, const DSA_METHOD *);
>const DSA_METHOD *DSA_get_method(DSA *d);
>
>DSA *DSA_new(void);
>DSA *DSA_new_method(ENGINE *engine);
>void DSA_free(DSA *r);
>
>int DSA_up_ref(DSA *r);
>int DSA_size(const DSA *);
>int DSA_bits(const DSA *d);
>int DSA_security_bits(const DSA *d);
>
>int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp);
>int DSA_sign(int type, const unsigned char *dgst, int dlen,
> unsigned char *sig, unsigned int *siglen, DSA *dsa);
>int DSA_verify(int type, const unsigned char *dgst, int dgst_len,
> const unsigned char *sigbuf, int siglen, DSA *dsa);
>
>
>int DSA_set_ex_data(DSA *d, int idx, void *arg);
>void *DSA_get_ex_data(DSA *d, int idx);
>
>DSA *d2i_DSAPublicKey(DSA **a, const unsigned char **pp, long length);
>DSA *d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length);
>DSA *d2i_DSAparams(DSA **a, const unsigned char **pp, long length);
>
>
>DSA *DSA_generate_parameters(int bits, unsigned char *seed, int seed_len, int *counter_ret, unsigned long *h_ret, void (*callback) (int, int, void *), void *cb_arg) __attribute__ ((deprecated));
># 133 "/usr/include/openssl/dsa.h" 3 4
>int DSA_generate_parameters_ex(DSA *dsa, int bits,
> const unsigned char *seed, int seed_len,
> int *counter_ret, unsigned long *h_ret,
> BN_GENCB *cb);
>
>int DSA_generate_key(DSA *a);
>int i2d_DSAPublicKey(const DSA *a, unsigned char **pp);
>int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp);
>int i2d_DSAparams(const DSA *a, unsigned char **pp);
>
>int DSAparams_print(BIO *bp, const DSA *x);
>int DSA_print(BIO *bp, const DSA *x, int off);
>
>int DSAparams_print_fp(FILE *fp, const DSA *x);
>int DSA_print_fp(FILE *bp, const DSA *x, int off);
># 163 "/usr/include/openssl/dsa.h" 3 4
>DH *DSA_dup_DH(const DSA *r);
># 174 "/usr/include/openssl/dsa.h" 3 4
>void DSA_get0_pqg(const DSA *d,
> const BIGNUM **p, const BIGNUM **q, const BIGNUM **g);
>int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g);
>void DSA_get0_key(const DSA *d,
> const BIGNUM **pub_key, const BIGNUM **priv_key);
>int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key);
>void DSA_clear_flags(DSA *d, int flags);
>int DSA_test_flags(const DSA *d, int flags);
>void DSA_set_flags(DSA *d, int flags);
>ENGINE *DSA_get0_engine(DSA *d);
>
>DSA_METHOD *DSA_meth_new(const char *name, int flags);
>void DSA_meth_free(DSA_METHOD *dsam);
>DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam);
>const char *DSA_meth_get0_name(const DSA_METHOD *dsam);
>int DSA_meth_set1_name(DSA_METHOD *dsam, const char *name);
>int DSA_meth_get_flags(DSA_METHOD *dsam);
>int DSA_meth_set_flags(DSA_METHOD *dsam, int flags);
>void *DSA_meth_get0_app_data(const DSA_METHOD *dsam);
>int DSA_meth_set0_app_data(DSA_METHOD *dsam, void *app_data);
>DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam))
> (const unsigned char *, int, DSA *);
>int DSA_meth_set_sign(DSA_METHOD *dsam,
> DSA_SIG *(*sign) (const unsigned char *, int, DSA *));
>int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam))
> (DSA *, BN_CTX *, BIGNUM **, BIGNUM **);
>int DSA_meth_set_sign_setup(DSA_METHOD *dsam,
> int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **));
>int (*DSA_meth_get_verify(const DSA_METHOD *dsam))
> (const unsigned char *, int , DSA_SIG *, DSA *);
>int DSA_meth_set_verify(DSA_METHOD *dsam,
> int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *));
>int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam))
> (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
> const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *);
>int DSA_meth_set_mod_exp(DSA_METHOD *dsam,
> int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
> const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *,
> BN_MONT_CTX *));
>int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam))
> (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
> BN_CTX *, BN_MONT_CTX *);
>int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam,
> int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
> const BIGNUM *, BN_CTX *, BN_MONT_CTX *));
>int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *);
>int DSA_meth_set_init(DSA_METHOD *dsam, int (*init)(DSA *));
>int (*DSA_meth_get_finish(const DSA_METHOD *dsam)) (DSA *);
>int DSA_meth_set_finish(DSA_METHOD *dsam, int (*finish) (DSA *));
>int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam))
> (DSA *, int, const unsigned char *, int, int *, unsigned long *,
> BN_GENCB *);
>int DSA_meth_set_paramgen(DSA_METHOD *dsam,
> int (*paramgen) (DSA *, int, const unsigned char *, int, int *,
> unsigned long *, BN_GENCB *));
>int (*DSA_meth_get_keygen(const DSA_METHOD *dsam)) (DSA *);
>int DSA_meth_set_keygen(DSA_METHOD *dsam, int (*keygen) (DSA *));
>
>
>
>
>
>
>
>int ERR_load_DSA_strings(void);
># 287 "/usr/include/openssl/dsa.h" 3 4
>}
># 33 "/usr/include/openssl/x509.h" 2 3 4
>
>
>
># 1 "/usr/include/openssl/sha.h" 1 3 4
># 14 "/usr/include/openssl/sha.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h" 1 3 4
># 15 "/usr/include/openssl/sha.h" 2 3 4
>
>
>extern "C" {
># 34 "/usr/include/openssl/sha.h" 3 4
>typedef struct SHAstate_st {
> unsigned int h0, h1, h2, h3, h4;
> unsigned int Nl, Nh;
> unsigned int data[16];
> unsigned int num;
>} SHA_CTX;
>
>int SHA1_Init(SHA_CTX *c);
>int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
>int SHA1_Final(unsigned char *md, SHA_CTX *c);
>unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
>void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
>
>
>
>
>
>typedef struct SHA256state_st {
> unsigned int h[8];
> unsigned int Nl, Nh;
> unsigned int data[16];
> unsigned int num, md_len;
>} SHA256_CTX;
>
>int SHA224_Init(SHA256_CTX *c);
>int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
>int SHA224_Final(unsigned char *md, SHA256_CTX *c);
>unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
>int SHA256_Init(SHA256_CTX *c);
>int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
>int SHA256_Final(unsigned char *md, SHA256_CTX *c);
>unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
>void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
># 95 "/usr/include/openssl/sha.h" 3 4
>typedef struct SHA512state_st {
> unsigned long long h[8];
> unsigned long long Nl, Nh;
> union {
> unsigned long long d[16];
> unsigned char p[(16*8)];
> } u;
> unsigned int num, md_len;
>} SHA512_CTX;
>
>int SHA384_Init(SHA512_CTX *c);
>int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
>int SHA384_Final(unsigned char *md, SHA512_CTX *c);
>unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
>int SHA512_Init(SHA512_CTX *c);
>int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
>int SHA512_Final(unsigned char *md, SHA512_CTX *c);
>unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
>void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
>
>
>}
># 37 "/usr/include/openssl/x509.h" 2 3 4
>
>
>extern "C" {
># 57 "/usr/include/openssl/x509.h" 3 4
>struct X509_algor_st {
> ASN1_OBJECT *algorithm;
> ASN1_TYPE *parameter;
>} ;
>
>typedef struct stack_st_X509_ALGOR X509_ALGORS;
>
>typedef struct X509_val_st {
> ASN1_TIME *notBefore;
> ASN1_TIME *notAfter;
>} X509_VAL;
>
>typedef struct X509_sig_st X509_SIG;
>
>typedef struct X509_name_entry_st X509_NAME_ENTRY;
>
>struct stack_st_X509_NAME_ENTRY; typedef int (*sk_X509_NAME_ENTRY_compfunc)(const X509_NAME_ENTRY * const *a, const X509_NAME_ENTRY *const *b); typedef void (*sk_X509_NAME_ENTRY_freefunc)(X509_NAME_ENTRY *a); typedef X509_NAME_ENTRY * (*sk_X509_NAME_ENTRY_copyfunc)(const X509_NAME_ENTRY *a); static inline int sk_X509_NAME_ENTRY_num(const struct stack_st_X509_NAME_ENTRY *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_NAME_ENTRY *sk_X509_NAME_ENTRY_value(const struct stack_st_X509_NAME_ENTRY *sk, int idx) { return (X509_NAME_ENTRY *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_NAME_ENTRY *sk_X509_NAME_ENTRY_new(sk_X509_NAME_ENTRY_compfunc compare) { return (struct stack_st_X509_NAME_ENTRY *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_NAME_ENTRY *sk_X509_NAME_ENTRY_new_null(void) { return (struct stack_st_X509_NAME_ENTRY *)OPENSSL_sk_new_null(); } static inline void sk_X509_NAME_ENTRY_free(struct stack_st_X509_NAME_ENTRY *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_NAME_ENTRY_zero(struct stack_st_X509_NAME_ENTRY *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_NAME_ENTRY *sk_X509_NAME_ENTRY_delete(struct stack_st_X509_NAME_ENTRY *sk, int i) { return (X509_NAME_ENTRY *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_NAME_ENTRY *sk_X509_NAME_ENTRY_delete_ptr(struct stack_st_X509_NAME_ENTRY *sk, X509_NAME_ENTRY *ptr) { return (X509_NAME_ENTRY *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_NAME_ENTRY_push(struct stack_st_X509_NAME_ENTRY *sk, X509_NAME_ENTRY *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_NAME_ENTRY_unshift(struct stack_st_X509_NAME_ENTRY *sk, X509_NAME_ENTRY *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_NAME_ENTRY *sk_X509_NAME_ENTRY_pop(struct stack_st_X509_NAME_ENTRY *sk) { return (X509_NAME_ENTRY *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_NAME_ENTRY *sk_X509_NAME_ENTRY_shift(struct stack_st_X509_NAME_ENTRY *sk) { return (X509_NAME_ENTRY *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_NAME_ENTRY_pop_free(struct stack_st_X509_NAME_ENTRY *sk, sk_X509_NAME_ENTRY_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_NAME_ENTRY_insert(struct stack_st_X509_NAME_ENTRY *sk, X509_NAME_ENTRY *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_NAME_ENTRY *sk_X509_NAME_ENTRY_set(struct stack_st_X509_NAME_ENTRY *sk, int idx, X509_NAME_ENTRY *ptr) { return (X509_NAME_ENTRY *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_NAME_ENTRY_find(struct stack_st_X509_NAME_ENTRY *sk, X509_NAME_ENTRY *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_NAME_ENTRY_find_ex(struct stack_st_X509_NAME_ENTRY *sk, X509_NAME_ENTRY *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_NAME_ENTRY_sort(struct stack_st_X509_NAME_ENTRY *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_NAME_ENTRY_is_sorted(const struct stack_st_X509_NAME_ENTRY *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_NAME_ENTRY * sk_X509_NAME_ENTRY_dup(const struct stack_st_X509_NAME_ENTRY *sk) { return (struct stack_st_X509_NAME_ENTRY *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_NAME_ENTRY *sk_X509_NAME_ENTRY_deep_copy(const struct stack_st_X509_NAME_ENTRY *sk, sk_X509_NAME_ENTRY_copyfunc copyfunc, sk_X509_NAME_ENTRY_freefunc freefunc) { return (struct stack_st_X509_NAME_ENTRY *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_NAME_ENTRY_compfunc sk_X509_NAME_ENTRY_set_cmp_func(struct stack_st_X509_NAME_ENTRY *sk, sk_X509_NAME_ENTRY_compfunc compare) { return (sk_X509_NAME_ENTRY_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>struct stack_st_X509_NAME; typedef int (*sk_X509_NAME_compfunc)(const X509_NAME * const *a, const X509_NAME *const *b); typedef void (*sk_X509_NAME_freefunc)(X509_NAME *a); typedef X509_NAME * (*sk_X509_NAME_copyfunc)(const X509_NAME *a); static inline int sk_X509_NAME_num(const struct stack_st_X509_NAME *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_NAME *sk_X509_NAME_value(const struct stack_st_X509_NAME *sk, int idx) { return (X509_NAME *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_NAME *sk_X509_NAME_new(sk_X509_NAME_compfunc compare) { return (struct stack_st_X509_NAME *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_NAME *sk_X509_NAME_new_null(void) { return (struct stack_st_X509_NAME *)OPENSSL_sk_new_null(); } static inline void sk_X509_NAME_free(struct stack_st_X509_NAME *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_NAME_zero(struct stack_st_X509_NAME *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_NAME *sk_X509_NAME_delete(struct stack_st_X509_NAME *sk, int i) { return (X509_NAME *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_NAME *sk_X509_NAME_delete_ptr(struct stack_st_X509_NAME *sk, X509_NAME *ptr) { return (X509_NAME *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_NAME_push(struct stack_st_X509_NAME *sk, X509_NAME *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_NAME_unshift(struct stack_st_X509_NAME *sk, X509_NAME *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_NAME *sk_X509_NAME_pop(struct stack_st_X509_NAME *sk) { return (X509_NAME *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_NAME *sk_X509_NAME_shift(struct stack_st_X509_NAME *sk) { return (X509_NAME *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_NAME_pop_free(struct stack_st_X509_NAME *sk, sk_X509_NAME_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_NAME_insert(struct stack_st_X509_NAME *sk, X509_NAME *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_NAME *sk_X509_NAME_set(struct stack_st_X509_NAME *sk, int idx, X509_NAME *ptr) { return (X509_NAME *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_NAME_find(struct stack_st_X509_NAME *sk, X509_NAME *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_NAME_find_ex(struct stack_st_X509_NAME *sk, X509_NAME *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_NAME_sort(struct stack_st_X509_NAME *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_NAME_is_sorted(const struct stack_st_X509_NAME *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_NAME * sk_X509_NAME_dup(const struct stack_st_X509_NAME *sk) { return (struct stack_st_X509_NAME *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_NAME *sk_X509_NAME_deep_copy(const struct stack_st_X509_NAME *sk, sk_X509_NAME_copyfunc copyfunc, sk_X509_NAME_freefunc freefunc) { return (struct stack_st_X509_NAME *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_NAME_compfunc sk_X509_NAME_set_cmp_func(struct stack_st_X509_NAME *sk, sk_X509_NAME_compfunc compare) { return (sk_X509_NAME_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>typedef struct X509_extension_st X509_EXTENSION;
>
>typedef struct stack_st_X509_EXTENSION X509_EXTENSIONS;
>
>struct stack_st_X509_EXTENSION; typedef int (*sk_X509_EXTENSION_compfunc)(const X509_EXTENSION * const *a, const X509_EXTENSION *const *b); typedef void (*sk_X509_EXTENSION_freefunc)(X509_EXTENSION *a); typedef X509_EXTENSION * (*sk_X509_EXTENSION_copyfunc)(const X509_EXTENSION *a); static inline int sk_X509_EXTENSION_num(const struct stack_st_X509_EXTENSION *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_EXTENSION *sk_X509_EXTENSION_value(const struct stack_st_X509_EXTENSION *sk, int idx) { return (X509_EXTENSION *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_EXTENSION *sk_X509_EXTENSION_new(sk_X509_EXTENSION_compfunc compare) { return (struct stack_st_X509_EXTENSION *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_EXTENSION *sk_X509_EXTENSION_new_null(void) { return (struct stack_st_X509_EXTENSION *)OPENSSL_sk_new_null(); } static inline void sk_X509_EXTENSION_free(struct stack_st_X509_EXTENSION *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_EXTENSION_zero(struct stack_st_X509_EXTENSION *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_EXTENSION *sk_X509_EXTENSION_delete(struct stack_st_X509_EXTENSION *sk, int i) { return (X509_EXTENSION *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_EXTENSION *sk_X509_EXTENSION_delete_ptr(struct stack_st_X509_EXTENSION *sk, X509_EXTENSION *ptr) { return (X509_EXTENSION *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_EXTENSION_push(struct stack_st_X509_EXTENSION *sk, X509_EXTENSION *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_EXTENSION_unshift(struct stack_st_X509_EXTENSION *sk, X509_EXTENSION *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_EXTENSION *sk_X509_EXTENSION_pop(struct stack_st_X509_EXTENSION *sk) { return (X509_EXTENSION *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_EXTENSION *sk_X509_EXTENSION_shift(struct stack_st_X509_EXTENSION *sk) { return (X509_EXTENSION *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_EXTENSION_pop_free(struct stack_st_X509_EXTENSION *sk, sk_X509_EXTENSION_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_EXTENSION_insert(struct stack_st_X509_EXTENSION *sk, X509_EXTENSION *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_EXTENSION *sk_X509_EXTENSION_set(struct stack_st_X509_EXTENSION *sk, int idx, X509_EXTENSION *ptr) { return (X509_EXTENSION *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_EXTENSION_find(struct stack_st_X509_EXTENSION *sk, X509_EXTENSION *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_EXTENSION_find_ex(struct stack_st_X509_EXTENSION *sk, X509_EXTENSION *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_EXTENSION_sort(struct stack_st_X509_EXTENSION *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_EXTENSION_is_sorted(const struct stack_st_X509_EXTENSION *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_EXTENSION * sk_X509_EXTENSION_dup(const struct stack_st_X509_EXTENSION *sk) { return (struct stack_st_X509_EXTENSION *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_EXTENSION *sk_X509_EXTENSION_deep_copy(const struct stack_st_X509_EXTENSION *sk, sk_X509_EXTENSION_copyfunc copyfunc, sk_X509_EXTENSION_freefunc freefunc) { return (struct stack_st_X509_EXTENSION *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_EXTENSION_compfunc sk_X509_EXTENSION_set_cmp_func(struct stack_st_X509_EXTENSION *sk, sk_X509_EXTENSION_compfunc compare) { return (sk_X509_EXTENSION_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct x509_attributes_st X509_ATTRIBUTE;
>
>struct stack_st_X509_ATTRIBUTE; typedef int (*sk_X509_ATTRIBUTE_compfunc)(const X509_ATTRIBUTE * const *a, const X509_ATTRIBUTE *const *b); typedef void (*sk_X509_ATTRIBUTE_freefunc)(X509_ATTRIBUTE *a); typedef X509_ATTRIBUTE * (*sk_X509_ATTRIBUTE_copyfunc)(const X509_ATTRIBUTE *a); static inline int sk_X509_ATTRIBUTE_num(const struct stack_st_X509_ATTRIBUTE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_ATTRIBUTE *sk_X509_ATTRIBUTE_value(const struct stack_st_X509_ATTRIBUTE *sk, int idx) { return (X509_ATTRIBUTE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_ATTRIBUTE *sk_X509_ATTRIBUTE_new(sk_X509_ATTRIBUTE_compfunc compare) { return (struct stack_st_X509_ATTRIBUTE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_ATTRIBUTE *sk_X509_ATTRIBUTE_new_null(void) { return (struct stack_st_X509_ATTRIBUTE *)OPENSSL_sk_new_null(); } static inline void sk_X509_ATTRIBUTE_free(struct stack_st_X509_ATTRIBUTE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_ATTRIBUTE_zero(struct stack_st_X509_ATTRIBUTE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_ATTRIBUTE *sk_X509_ATTRIBUTE_delete(struct stack_st_X509_ATTRIBUTE *sk, int i) { return (X509_ATTRIBUTE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_ATTRIBUTE *sk_X509_ATTRIBUTE_delete_ptr(struct stack_st_X509_ATTRIBUTE *sk, X509_ATTRIBUTE *ptr) { return (X509_ATTRIBUTE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_ATTRIBUTE_push(struct stack_st_X509_ATTRIBUTE *sk, X509_ATTRIBUTE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_ATTRIBUTE_unshift(struct stack_st_X509_ATTRIBUTE *sk, X509_ATTRIBUTE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_ATTRIBUTE *sk_X509_ATTRIBUTE_pop(struct stack_st_X509_ATTRIBUTE *sk) { return (X509_ATTRIBUTE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_ATTRIBUTE *sk_X509_ATTRIBUTE_shift(struct stack_st_X509_ATTRIBUTE *sk) { return (X509_ATTRIBUTE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_ATTRIBUTE_pop_free(struct stack_st_X509_ATTRIBUTE *sk, sk_X509_ATTRIBUTE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_ATTRIBUTE_insert(struct stack_st_X509_ATTRIBUTE *sk, X509_ATTRIBUTE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_ATTRIBUTE *sk_X509_ATTRIBUTE_set(struct stack_st_X509_ATTRIBUTE *sk, int idx, X509_ATTRIBUTE *ptr) { return (X509_ATTRIBUTE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_ATTRIBUTE_find(struct stack_st_X509_ATTRIBUTE *sk, X509_ATTRIBUTE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_ATTRIBUTE_find_ex(struct stack_st_X509_ATTRIBUTE *sk, X509_ATTRIBUTE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_ATTRIBUTE_sort(struct stack_st_X509_ATTRIBUTE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_ATTRIBUTE_is_sorted(const struct stack_st_X509_ATTRIBUTE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_ATTRIBUTE * sk_X509_ATTRIBUTE_dup(const struct stack_st_X509_ATTRIBUTE *sk) { return (struct stack_st_X509_ATTRIBUTE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_ATTRIBUTE *sk_X509_ATTRIBUTE_deep_copy(const struct stack_st_X509_ATTRIBUTE *sk, sk_X509_ATTRIBUTE_copyfunc copyfunc, sk_X509_ATTRIBUTE_freefunc freefunc) { return (struct stack_st_X509_ATTRIBUTE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_ATTRIBUTE_compfunc sk_X509_ATTRIBUTE_set_cmp_func(struct stack_st_X509_ATTRIBUTE *sk, sk_X509_ATTRIBUTE_compfunc compare) { return (sk_X509_ATTRIBUTE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct X509_req_info_st X509_REQ_INFO;
>
>typedef struct X509_req_st X509_REQ;
>
>typedef struct x509_cert_aux_st X509_CERT_AUX;
>
>typedef struct x509_cinf_st X509_CINF;
>
>struct stack_st_X509; typedef int (*sk_X509_compfunc)(const X509 * const *a, const X509 *const *b); typedef void (*sk_X509_freefunc)(X509 *a); typedef X509 * (*sk_X509_copyfunc)(const X509 *a); static inline int sk_X509_num(const struct stack_st_X509 *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509 *sk_X509_value(const struct stack_st_X509 *sk, int idx) { return (X509 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509 *sk_X509_new(sk_X509_compfunc compare) { return (struct stack_st_X509 *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509 *sk_X509_new_null(void) { return (struct stack_st_X509 *)OPENSSL_sk_new_null(); } static inline void sk_X509_free(struct stack_st_X509 *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_zero(struct stack_st_X509 *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509 *sk_X509_delete(struct stack_st_X509 *sk, int i) { return (X509 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509 *sk_X509_delete_ptr(struct stack_st_X509 *sk, X509 *ptr) { return (X509 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_push(struct stack_st_X509 *sk, X509 *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_unshift(struct stack_st_X509 *sk, X509 *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509 *sk_X509_pop(struct stack_st_X509 *sk) { return (X509 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509 *sk_X509_shift(struct stack_st_X509 *sk) { return (X509 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_pop_free(struct stack_st_X509 *sk, sk_X509_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_insert(struct stack_st_X509 *sk, X509 *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509 *sk_X509_set(struct stack_st_X509 *sk, int idx, X509 *ptr) { return (X509 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_find(struct stack_st_X509 *sk, X509 *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_find_ex(struct stack_st_X509 *sk, X509 *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_sort(struct stack_st_X509 *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_is_sorted(const struct stack_st_X509 *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509 * sk_X509_dup(const struct stack_st_X509 *sk) { return (struct stack_st_X509 *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509 *sk_X509_deep_copy(const struct stack_st_X509 *sk, sk_X509_copyfunc copyfunc, sk_X509_freefunc freefunc) { return (struct stack_st_X509 *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_compfunc sk_X509_set_cmp_func(struct stack_st_X509 *sk, sk_X509_compfunc compare) { return (sk_X509_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>typedef struct x509_trust_st {
> int trust;
> int flags;
> int (*check_trust) (struct x509_trust_st *, X509 *, int);
> char *name;
> int arg1;
> void *arg2;
>} X509_TRUST;
>
>struct stack_st_X509_TRUST; typedef int (*sk_X509_TRUST_compfunc)(const X509_TRUST * const *a, const X509_TRUST *const *b); typedef void (*sk_X509_TRUST_freefunc)(X509_TRUST *a); typedef X509_TRUST * (*sk_X509_TRUST_copyfunc)(const X509_TRUST *a); static inline int sk_X509_TRUST_num(const struct stack_st_X509_TRUST *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_TRUST *sk_X509_TRUST_value(const struct stack_st_X509_TRUST *sk, int idx) { return (X509_TRUST *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_TRUST *sk_X509_TRUST_new(sk_X509_TRUST_compfunc compare) { return (struct stack_st_X509_TRUST *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_TRUST *sk_X509_TRUST_new_null(void) { return (struct stack_st_X509_TRUST *)OPENSSL_sk_new_null(); } static inline void sk_X509_TRUST_free(struct stack_st_X509_TRUST *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_TRUST_zero(struct stack_st_X509_TRUST *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_TRUST *sk_X509_TRUST_delete(struct stack_st_X509_TRUST *sk, int i) { return (X509_TRUST *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_TRUST *sk_X509_TRUST_delete_ptr(struct stack_st_X509_TRUST *sk, X509_TRUST *ptr) { return (X509_TRUST *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_TRUST_push(struct stack_st_X509_TRUST *sk, X509_TRUST *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_TRUST_unshift(struct stack_st_X509_TRUST *sk, X509_TRUST *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_TRUST *sk_X509_TRUST_pop(struct stack_st_X509_TRUST *sk) { return (X509_TRUST *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_TRUST *sk_X509_TRUST_shift(struct stack_st_X509_TRUST *sk) { return (X509_TRUST *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_TRUST_pop_free(struct stack_st_X509_TRUST *sk, sk_X509_TRUST_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_TRUST_insert(struct stack_st_X509_TRUST *sk, X509_TRUST *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_TRUST *sk_X509_TRUST_set(struct stack_st_X509_TRUST *sk, int idx, X509_TRUST *ptr) { return (X509_TRUST *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_TRUST_find(struct stack_st_X509_TRUST *sk, X509_TRUST *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_TRUST_find_ex(struct stack_st_X509_TRUST *sk, X509_TRUST *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_TRUST_sort(struct stack_st_X509_TRUST *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_TRUST_is_sorted(const struct stack_st_X509_TRUST *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_TRUST * sk_X509_TRUST_dup(const struct stack_st_X509_TRUST *sk) { return (struct stack_st_X509_TRUST *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_TRUST *sk_X509_TRUST_deep_copy(const struct stack_st_X509_TRUST *sk, sk_X509_TRUST_copyfunc copyfunc, sk_X509_TRUST_freefunc freefunc) { return (struct stack_st_X509_TRUST *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_TRUST_compfunc sk_X509_TRUST_set_cmp_func(struct stack_st_X509_TRUST *sk, sk_X509_TRUST_compfunc compare) { return (sk_X509_TRUST_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 222 "/usr/include/openssl/x509.h" 3 4
>struct stack_st_X509_REVOKED; typedef int (*sk_X509_REVOKED_compfunc)(const X509_REVOKED * const *a, const X509_REVOKED *const *b); typedef void (*sk_X509_REVOKED_freefunc)(X509_REVOKED *a); typedef X509_REVOKED * (*sk_X509_REVOKED_copyfunc)(const X509_REVOKED *a); static inline int sk_X509_REVOKED_num(const struct stack_st_X509_REVOKED *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_REVOKED *sk_X509_REVOKED_value(const struct stack_st_X509_REVOKED *sk, int idx) { return (X509_REVOKED *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_REVOKED *sk_X509_REVOKED_new(sk_X509_REVOKED_compfunc compare) { return (struct stack_st_X509_REVOKED *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_REVOKED *sk_X509_REVOKED_new_null(void) { return (struct stack_st_X509_REVOKED *)OPENSSL_sk_new_null(); } static inline void sk_X509_REVOKED_free(struct stack_st_X509_REVOKED *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_REVOKED_zero(struct stack_st_X509_REVOKED *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_REVOKED *sk_X509_REVOKED_delete(struct stack_st_X509_REVOKED *sk, int i) { return (X509_REVOKED *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_REVOKED *sk_X509_REVOKED_delete_ptr(struct stack_st_X509_REVOKED *sk, X509_REVOKED *ptr) { return (X509_REVOKED *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_REVOKED_push(struct stack_st_X509_REVOKED *sk, X509_REVOKED *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_REVOKED_unshift(struct stack_st_X509_REVOKED *sk, X509_REVOKED *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_REVOKED *sk_X509_REVOKED_pop(struct stack_st_X509_REVOKED *sk) { return (X509_REVOKED *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_REVOKED *sk_X509_REVOKED_shift(struct stack_st_X509_REVOKED *sk) { return (X509_REVOKED *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_REVOKED_pop_free(struct stack_st_X509_REVOKED *sk, sk_X509_REVOKED_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_REVOKED_insert(struct stack_st_X509_REVOKED *sk, X509_REVOKED *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_REVOKED *sk_X509_REVOKED_set(struct stack_st_X509_REVOKED *sk, int idx, X509_REVOKED *ptr) { return (X509_REVOKED *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_REVOKED_find(struct stack_st_X509_REVOKED *sk, X509_REVOKED *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_REVOKED_find_ex(struct stack_st_X509_REVOKED *sk, X509_REVOKED *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_REVOKED_sort(struct stack_st_X509_REVOKED *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_REVOKED_is_sorted(const struct stack_st_X509_REVOKED *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_REVOKED * sk_X509_REVOKED_dup(const struct stack_st_X509_REVOKED *sk) { return (struct stack_st_X509_REVOKED *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_REVOKED *sk_X509_REVOKED_deep_copy(const struct stack_st_X509_REVOKED *sk, sk_X509_REVOKED_copyfunc copyfunc, sk_X509_REVOKED_freefunc freefunc) { return (struct stack_st_X509_REVOKED *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_REVOKED_compfunc sk_X509_REVOKED_set_cmp_func(struct stack_st_X509_REVOKED *sk, sk_X509_REVOKED_compfunc compare) { return (sk_X509_REVOKED_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct X509_crl_info_st X509_CRL_INFO;
>
>struct stack_st_X509_CRL; typedef int (*sk_X509_CRL_compfunc)(const X509_CRL * const *a, const X509_CRL *const *b); typedef void (*sk_X509_CRL_freefunc)(X509_CRL *a); typedef X509_CRL * (*sk_X509_CRL_copyfunc)(const X509_CRL *a); static inline int sk_X509_CRL_num(const struct stack_st_X509_CRL *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_CRL *sk_X509_CRL_value(const struct stack_st_X509_CRL *sk, int idx) { return (X509_CRL *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_CRL *sk_X509_CRL_new(sk_X509_CRL_compfunc compare) { return (struct stack_st_X509_CRL *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_CRL *sk_X509_CRL_new_null(void) { return (struct stack_st_X509_CRL *)OPENSSL_sk_new_null(); } static inline void sk_X509_CRL_free(struct stack_st_X509_CRL *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_CRL_zero(struct stack_st_X509_CRL *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_CRL *sk_X509_CRL_delete(struct stack_st_X509_CRL *sk, int i) { return (X509_CRL *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_CRL *sk_X509_CRL_delete_ptr(struct stack_st_X509_CRL *sk, X509_CRL *ptr) { return (X509_CRL *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_CRL_push(struct stack_st_X509_CRL *sk, X509_CRL *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_CRL_unshift(struct stack_st_X509_CRL *sk, X509_CRL *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_CRL *sk_X509_CRL_pop(struct stack_st_X509_CRL *sk) { return (X509_CRL *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_CRL *sk_X509_CRL_shift(struct stack_st_X509_CRL *sk) { return (X509_CRL *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_CRL_pop_free(struct stack_st_X509_CRL *sk, sk_X509_CRL_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_CRL_insert(struct stack_st_X509_CRL *sk, X509_CRL *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_CRL *sk_X509_CRL_set(struct stack_st_X509_CRL *sk, int idx, X509_CRL *ptr) { return (X509_CRL *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_CRL_find(struct stack_st_X509_CRL *sk, X509_CRL *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_CRL_find_ex(struct stack_st_X509_CRL *sk, X509_CRL *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_CRL_sort(struct stack_st_X509_CRL *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_CRL_is_sorted(const struct stack_st_X509_CRL *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_CRL * sk_X509_CRL_dup(const struct stack_st_X509_CRL *sk) { return (struct stack_st_X509_CRL *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_CRL *sk_X509_CRL_deep_copy(const struct stack_st_X509_CRL *sk, sk_X509_CRL_copyfunc copyfunc, sk_X509_CRL_freefunc freefunc) { return (struct stack_st_X509_CRL *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_CRL_compfunc sk_X509_CRL_set_cmp_func(struct stack_st_X509_CRL *sk, sk_X509_CRL_compfunc compare) { return (sk_X509_CRL_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct private_key_st {
> int version;
>
> X509_ALGOR *enc_algor;
> ASN1_OCTET_STRING *enc_pkey;
>
> EVP_PKEY *dec_pkey;
>
> int key_length;
> char *key_data;
> int key_free;
>
> EVP_CIPHER_INFO cipher;
>} X509_PKEY;
>
>typedef struct X509_info_st {
> X509 *x509;
> X509_CRL *crl;
> X509_PKEY *x_pkey;
> EVP_CIPHER_INFO enc_cipher;
> int enc_len;
> char *enc_data;
>} X509_INFO;
>
>struct stack_st_X509_INFO; typedef int (*sk_X509_INFO_compfunc)(const X509_INFO * const *a, const X509_INFO *const *b); typedef void (*sk_X509_INFO_freefunc)(X509_INFO *a); typedef X509_INFO * (*sk_X509_INFO_copyfunc)(const X509_INFO *a); static inline int sk_X509_INFO_num(const struct stack_st_X509_INFO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_INFO *sk_X509_INFO_value(const struct stack_st_X509_INFO *sk, int idx) { return (X509_INFO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_INFO *sk_X509_INFO_new(sk_X509_INFO_compfunc compare) { return (struct stack_st_X509_INFO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_INFO *sk_X509_INFO_new_null(void) { return (struct stack_st_X509_INFO *)OPENSSL_sk_new_null(); } static inline void sk_X509_INFO_free(struct stack_st_X509_INFO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_INFO_zero(struct stack_st_X509_INFO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_INFO *sk_X509_INFO_delete(struct stack_st_X509_INFO *sk, int i) { return (X509_INFO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_INFO *sk_X509_INFO_delete_ptr(struct stack_st_X509_INFO *sk, X509_INFO *ptr) { return (X509_INFO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_INFO_push(struct stack_st_X509_INFO *sk, X509_INFO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_INFO_unshift(struct stack_st_X509_INFO *sk, X509_INFO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_INFO *sk_X509_INFO_pop(struct stack_st_X509_INFO *sk) { return (X509_INFO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_INFO *sk_X509_INFO_shift(struct stack_st_X509_INFO *sk) { return (X509_INFO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_INFO_pop_free(struct stack_st_X509_INFO *sk, sk_X509_INFO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_INFO_insert(struct stack_st_X509_INFO *sk, X509_INFO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_INFO *sk_X509_INFO_set(struct stack_st_X509_INFO *sk, int idx, X509_INFO *ptr) { return (X509_INFO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_INFO_find(struct stack_st_X509_INFO *sk, X509_INFO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_INFO_find_ex(struct stack_st_X509_INFO *sk, X509_INFO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_INFO_sort(struct stack_st_X509_INFO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_INFO_is_sorted(const struct stack_st_X509_INFO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_INFO * sk_X509_INFO_dup(const struct stack_st_X509_INFO *sk) { return (struct stack_st_X509_INFO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_INFO *sk_X509_INFO_deep_copy(const struct stack_st_X509_INFO *sk, sk_X509_INFO_copyfunc copyfunc, sk_X509_INFO_freefunc freefunc) { return (struct stack_st_X509_INFO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_INFO_compfunc sk_X509_INFO_set_cmp_func(struct stack_st_X509_INFO *sk, sk_X509_INFO_compfunc compare) { return (sk_X509_INFO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>
>
>
>typedef struct Netscape_spkac_st {
> X509_PUBKEY *pubkey;
> ASN1_IA5STRING *challenge;
>} NETSCAPE_SPKAC;
>
>typedef struct Netscape_spki_st {
> NETSCAPE_SPKAC *spkac;
> X509_ALGOR sig_algor;
> ASN1_BIT_STRING *signature;
>} NETSCAPE_SPKI;
>
>
>typedef struct Netscape_certificate_sequence {
> ASN1_OBJECT *type;
> struct stack_st_X509 *certs;
>} NETSCAPE_CERT_SEQUENCE;
># 285 "/usr/include/openssl/x509.h" 3 4
>typedef struct PBEPARAM_st {
> ASN1_OCTET_STRING *salt;
> ASN1_INTEGER *iter;
>} PBEPARAM;
>
>
>
>typedef struct PBE2PARAM_st {
> X509_ALGOR *keyfunc;
> X509_ALGOR *encryption;
>} PBE2PARAM;
>
>typedef struct PBKDF2PARAM_st {
>
> ASN1_TYPE *salt;
> ASN1_INTEGER *iter;
> ASN1_INTEGER *keylength;
> X509_ALGOR *prf;
>} PBKDF2PARAM;
>
>
>}
>
>
># 1 "/usr/include/openssl/x509_vfy.h" 1 3 4
># 20 "/usr/include/openssl/x509_vfy.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 21 "/usr/include/openssl/x509_vfy.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
># 47 "/usr/include/openssl/x509_vfy.h" 3 4
>typedef enum {
> X509_LU_NONE = 0,
> X509_LU_X509, X509_LU_CRL
>} X509_LOOKUP_TYPE;
>
>
>
>
>
>
>struct stack_st_X509_LOOKUP; typedef int (*sk_X509_LOOKUP_compfunc)(const X509_LOOKUP * const *a, const X509_LOOKUP *const *b); typedef void (*sk_X509_LOOKUP_freefunc)(X509_LOOKUP *a); typedef X509_LOOKUP * (*sk_X509_LOOKUP_copyfunc)(const X509_LOOKUP *a); static inline int sk_X509_LOOKUP_num(const struct stack_st_X509_LOOKUP *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_LOOKUP *sk_X509_LOOKUP_value(const struct stack_st_X509_LOOKUP *sk, int idx) { return (X509_LOOKUP *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_LOOKUP *sk_X509_LOOKUP_new(sk_X509_LOOKUP_compfunc compare) { return (struct stack_st_X509_LOOKUP *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_LOOKUP *sk_X509_LOOKUP_new_null(void) { return (struct stack_st_X509_LOOKUP *)OPENSSL_sk_new_null(); } static inline void sk_X509_LOOKUP_free(struct stack_st_X509_LOOKUP *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_LOOKUP_zero(struct stack_st_X509_LOOKUP *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_LOOKUP *sk_X509_LOOKUP_delete(struct stack_st_X509_LOOKUP *sk, int i) { return (X509_LOOKUP *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_LOOKUP *sk_X509_LOOKUP_delete_ptr(struct stack_st_X509_LOOKUP *sk, X509_LOOKUP *ptr) { return (X509_LOOKUP *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_LOOKUP_push(struct stack_st_X509_LOOKUP *sk, X509_LOOKUP *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_LOOKUP_unshift(struct stack_st_X509_LOOKUP *sk, X509_LOOKUP *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_LOOKUP *sk_X509_LOOKUP_pop(struct stack_st_X509_LOOKUP *sk) { return (X509_LOOKUP *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_LOOKUP *sk_X509_LOOKUP_shift(struct stack_st_X509_LOOKUP *sk) { return (X509_LOOKUP *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_LOOKUP_pop_free(struct stack_st_X509_LOOKUP *sk, sk_X509_LOOKUP_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_LOOKUP_insert(struct stack_st_X509_LOOKUP *sk, X509_LOOKUP *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_LOOKUP *sk_X509_LOOKUP_set(struct stack_st_X509_LOOKUP *sk, int idx, X509_LOOKUP *ptr) { return (X509_LOOKUP *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_LOOKUP_find(struct stack_st_X509_LOOKUP *sk, X509_LOOKUP *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_LOOKUP_find_ex(struct stack_st_X509_LOOKUP *sk, X509_LOOKUP *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_LOOKUP_sort(struct stack_st_X509_LOOKUP *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_LOOKUP_is_sorted(const struct stack_st_X509_LOOKUP *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_LOOKUP * sk_X509_LOOKUP_dup(const struct stack_st_X509_LOOKUP *sk) { return (struct stack_st_X509_LOOKUP *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_LOOKUP *sk_X509_LOOKUP_deep_copy(const struct stack_st_X509_LOOKUP *sk, sk_X509_LOOKUP_copyfunc copyfunc, sk_X509_LOOKUP_freefunc freefunc) { return (struct stack_st_X509_LOOKUP *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_LOOKUP_compfunc sk_X509_LOOKUP_set_cmp_func(struct stack_st_X509_LOOKUP *sk, sk_X509_LOOKUP_compfunc compare) { return (sk_X509_LOOKUP_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct stack_st_X509_OBJECT; typedef int (*sk_X509_OBJECT_compfunc)(const X509_OBJECT * const *a, const X509_OBJECT *const *b); typedef void (*sk_X509_OBJECT_freefunc)(X509_OBJECT *a); typedef X509_OBJECT * (*sk_X509_OBJECT_copyfunc)(const X509_OBJECT *a); static inline int sk_X509_OBJECT_num(const struct stack_st_X509_OBJECT *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_OBJECT *sk_X509_OBJECT_value(const struct stack_st_X509_OBJECT *sk, int idx) { return (X509_OBJECT *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_OBJECT *sk_X509_OBJECT_new(sk_X509_OBJECT_compfunc compare) { return (struct stack_st_X509_OBJECT *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_OBJECT *sk_X509_OBJECT_new_null(void) { return (struct stack_st_X509_OBJECT *)OPENSSL_sk_new_null(); } static inline void sk_X509_OBJECT_free(struct stack_st_X509_OBJECT *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_OBJECT_zero(struct stack_st_X509_OBJECT *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_OBJECT *sk_X509_OBJECT_delete(struct stack_st_X509_OBJECT *sk, int i) { return (X509_OBJECT *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_OBJECT *sk_X509_OBJECT_delete_ptr(struct stack_st_X509_OBJECT *sk, X509_OBJECT *ptr) { return (X509_OBJECT *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_OBJECT_push(struct stack_st_X509_OBJECT *sk, X509_OBJECT *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_OBJECT_unshift(struct stack_st_X509_OBJECT *sk, X509_OBJECT *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_OBJECT *sk_X509_OBJECT_pop(struct stack_st_X509_OBJECT *sk) { return (X509_OBJECT *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_OBJECT *sk_X509_OBJECT_shift(struct stack_st_X509_OBJECT *sk) { return (X509_OBJECT *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_OBJECT_pop_free(struct stack_st_X509_OBJECT *sk, sk_X509_OBJECT_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_OBJECT_insert(struct stack_st_X509_OBJECT *sk, X509_OBJECT *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_OBJECT *sk_X509_OBJECT_set(struct stack_st_X509_OBJECT *sk, int idx, X509_OBJECT *ptr) { return (X509_OBJECT *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_OBJECT_find(struct stack_st_X509_OBJECT *sk, X509_OBJECT *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_OBJECT_find_ex(struct stack_st_X509_OBJECT *sk, X509_OBJECT *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_OBJECT_sort(struct stack_st_X509_OBJECT *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_OBJECT_is_sorted(const struct stack_st_X509_OBJECT *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_OBJECT * sk_X509_OBJECT_dup(const struct stack_st_X509_OBJECT *sk) { return (struct stack_st_X509_OBJECT *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_OBJECT *sk_X509_OBJECT_deep_copy(const struct stack_st_X509_OBJECT *sk, sk_X509_OBJECT_copyfunc copyfunc, sk_X509_OBJECT_freefunc freefunc) { return (struct stack_st_X509_OBJECT *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_OBJECT_compfunc sk_X509_OBJECT_set_cmp_func(struct stack_st_X509_OBJECT *sk, sk_X509_OBJECT_compfunc compare) { return (sk_X509_OBJECT_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct stack_st_X509_VERIFY_PARAM; typedef int (*sk_X509_VERIFY_PARAM_compfunc)(const X509_VERIFY_PARAM * const *a, const X509_VERIFY_PARAM *const *b); typedef void (*sk_X509_VERIFY_PARAM_freefunc)(X509_VERIFY_PARAM *a); typedef X509_VERIFY_PARAM * (*sk_X509_VERIFY_PARAM_copyfunc)(const X509_VERIFY_PARAM *a); static inline int sk_X509_VERIFY_PARAM_num(const struct stack_st_X509_VERIFY_PARAM *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_value(const struct stack_st_X509_VERIFY_PARAM *sk, int idx) { return (X509_VERIFY_PARAM *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_new(sk_X509_VERIFY_PARAM_compfunc compare) { return (struct stack_st_X509_VERIFY_PARAM *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_new_null(void) { return (struct stack_st_X509_VERIFY_PARAM *)OPENSSL_sk_new_null(); } static inline void sk_X509_VERIFY_PARAM_free(struct stack_st_X509_VERIFY_PARAM *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_VERIFY_PARAM_zero(struct stack_st_X509_VERIFY_PARAM *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_delete(struct stack_st_X509_VERIFY_PARAM *sk, int i) { return (X509_VERIFY_PARAM *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_delete_ptr(struct stack_st_X509_VERIFY_PARAM *sk, X509_VERIFY_PARAM *ptr) { return (X509_VERIFY_PARAM *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_VERIFY_PARAM_push(struct stack_st_X509_VERIFY_PARAM *sk, X509_VERIFY_PARAM *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_VERIFY_PARAM_unshift(struct stack_st_X509_VERIFY_PARAM *sk, X509_VERIFY_PARAM *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_pop(struct stack_st_X509_VERIFY_PARAM *sk) { return (X509_VERIFY_PARAM *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_shift(struct stack_st_X509_VERIFY_PARAM *sk) { return (X509_VERIFY_PARAM *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_VERIFY_PARAM_pop_free(struct stack_st_X509_VERIFY_PARAM *sk, sk_X509_VERIFY_PARAM_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_VERIFY_PARAM_insert(struct stack_st_X509_VERIFY_PARAM *sk, X509_VERIFY_PARAM *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_set(struct stack_st_X509_VERIFY_PARAM *sk, int idx, X509_VERIFY_PARAM *ptr) { return (X509_VERIFY_PARAM *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_VERIFY_PARAM_find(struct stack_st_X509_VERIFY_PARAM *sk, X509_VERIFY_PARAM *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_VERIFY_PARAM_find_ex(struct stack_st_X509_VERIFY_PARAM *sk, X509_VERIFY_PARAM *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_VERIFY_PARAM_sort(struct stack_st_X509_VERIFY_PARAM *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_VERIFY_PARAM_is_sorted(const struct stack_st_X509_VERIFY_PARAM *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_VERIFY_PARAM * sk_X509_VERIFY_PARAM_dup(const struct stack_st_X509_VERIFY_PARAM *sk) { return (struct stack_st_X509_VERIFY_PARAM *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_VERIFY_PARAM *sk_X509_VERIFY_PARAM_deep_copy(const struct stack_st_X509_VERIFY_PARAM *sk, sk_X509_VERIFY_PARAM_copyfunc copyfunc, sk_X509_VERIFY_PARAM_freefunc freefunc) { return (struct stack_st_X509_VERIFY_PARAM *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_VERIFY_PARAM_compfunc sk_X509_VERIFY_PARAM_set_cmp_func(struct stack_st_X509_VERIFY_PARAM *sk, sk_X509_VERIFY_PARAM_compfunc compare) { return (sk_X509_VERIFY_PARAM_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>int X509_STORE_set_depth(X509_STORE *store, int depth);
>
>typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX *);
>typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *);
>typedef int (*X509_STORE_CTX_get_issuer_fn)(X509 **issuer,
> X509_STORE_CTX *ctx, X509 *x);
>typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX *ctx,
> X509 *x, X509 *issuer);
>typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX *ctx);
>typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX *ctx,
> X509_CRL **crl, X509 *x);
>typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX *ctx, X509_CRL *crl);
>typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX *ctx,
> X509_CRL *crl, X509 *x);
>typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX *ctx);
>typedef struct stack_st_X509 *(*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX *ctx,
> X509_NAME *nm);
>typedef struct stack_st_X509_CRL *(*X509_STORE_CTX_lookup_crls_fn)(X509_STORE_CTX *ctx,
> X509_NAME *nm);
>typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX *ctx);
>
>
>void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth);
># 248 "/usr/include/openssl/x509_vfy.h" 3 4
>int X509_OBJECT_idx_by_subject(struct stack_st_X509_OBJECT *h, X509_LOOKUP_TYPE type,
> X509_NAME *name);
>X509_OBJECT *X509_OBJECT_retrieve_by_subject(struct stack_st_X509_OBJECT *h,
> X509_LOOKUP_TYPE type,
> X509_NAME *name);
>X509_OBJECT *X509_OBJECT_retrieve_match(struct stack_st_X509_OBJECT *h,
> X509_OBJECT *x);
>int X509_OBJECT_up_ref_count(X509_OBJECT *a);
>X509_OBJECT *X509_OBJECT_new(void);
>void X509_OBJECT_free(X509_OBJECT *a);
>X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a);
>X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a);
>X509_CRL *X509_OBJECT_get0_X509_CRL(X509_OBJECT *a);
>X509_STORE *X509_STORE_new(void);
>void X509_STORE_free(X509_STORE *v);
>int X509_STORE_lock(X509_STORE *ctx);
>int X509_STORE_unlock(X509_STORE *ctx);
>int X509_STORE_up_ref(X509_STORE *v);
>struct stack_st_X509_OBJECT *X509_STORE_get0_objects(X509_STORE *v);
>
>struct stack_st_X509 *X509_STORE_CTX_get1_certs(X509_STORE_CTX *st, X509_NAME *nm);
>struct stack_st_X509_CRL *X509_STORE_CTX_get1_crls(X509_STORE_CTX *st, X509_NAME *nm);
>int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags);
>int X509_STORE_set_purpose(X509_STORE *ctx, int purpose);
>int X509_STORE_set_trust(X509_STORE *ctx, int trust);
>int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *pm);
>X509_VERIFY_PARAM *X509_STORE_get0_param(X509_STORE *ctx);
>
>void X509_STORE_set_verify(X509_STORE *ctx, X509_STORE_CTX_verify_fn verify);
>
>
>void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx,
> X509_STORE_CTX_verify_fn verify);
>X509_STORE_CTX_verify_fn X509_STORE_get_verify(X509_STORE *ctx);
>void X509_STORE_set_verify_cb(X509_STORE *ctx,
> X509_STORE_CTX_verify_cb verify_cb);
>
>
>X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(X509_STORE *ctx);
>void X509_STORE_set_get_issuer(X509_STORE *ctx,
> X509_STORE_CTX_get_issuer_fn get_issuer);
>X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(X509_STORE *ctx);
>void X509_STORE_set_check_issued(X509_STORE *ctx,
> X509_STORE_CTX_check_issued_fn check_issued);
>X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(X509_STORE *ctx);
>void X509_STORE_set_check_revocation(X509_STORE *ctx,
> X509_STORE_CTX_check_revocation_fn check_revocation);
>X509_STORE_CTX_check_revocation_fn X509_STORE_get_check_revocation(X509_STORE *ctx);
>void X509_STORE_set_get_crl(X509_STORE *ctx,
> X509_STORE_CTX_get_crl_fn get_crl);
>X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(X509_STORE *ctx);
>void X509_STORE_set_check_crl(X509_STORE *ctx,
> X509_STORE_CTX_check_crl_fn check_crl);
>X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(X509_STORE *ctx);
>void X509_STORE_set_cert_crl(X509_STORE *ctx,
> X509_STORE_CTX_cert_crl_fn cert_crl);
>X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(X509_STORE *ctx);
>void X509_STORE_set_check_policy(X509_STORE *ctx,
> X509_STORE_CTX_check_policy_fn check_policy);
>X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(X509_STORE *ctx);
>void X509_STORE_set_lookup_certs(X509_STORE *ctx,
> X509_STORE_CTX_lookup_certs_fn lookup_certs);
>X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(X509_STORE *ctx);
>void X509_STORE_set_lookup_crls(X509_STORE *ctx,
> X509_STORE_CTX_lookup_crls_fn lookup_crls);
>
>
>X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(X509_STORE *ctx);
>void X509_STORE_set_cleanup(X509_STORE *ctx,
> X509_STORE_CTX_cleanup_fn cleanup);
>X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(X509_STORE *ctx);
>
>
>
>int X509_STORE_set_ex_data(X509_STORE *ctx, int idx, void *data);
>void *X509_STORE_get_ex_data(X509_STORE *ctx, int idx);
>
>X509_STORE_CTX *X509_STORE_CTX_new(void);
>
>int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
>
>void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
>int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store,
> X509 *x509, struct stack_st_X509 *chain);
>void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, struct stack_st_X509 *sk);
>void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx);
>
>X509_STORE *X509_STORE_CTX_get0_store(X509_STORE_CTX *ctx);
>X509 *X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx);
>struct stack_st_X509* X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx);
>void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, struct stack_st_X509 *sk);
>void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
> X509_STORE_CTX_verify_cb verify);
>X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx);
>X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx);
>X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(X509_STORE_CTX *ctx);
>X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(X509_STORE_CTX *ctx);
>X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(X509_STORE_CTX *ctx);
>X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(X509_STORE_CTX *ctx);
>X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(X509_STORE_CTX *ctx);
>X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(X509_STORE_CTX *ctx);
>X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(X509_STORE_CTX *ctx);
>X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(X509_STORE_CTX *ctx);
>X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(X509_STORE_CTX *ctx);
>X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(X509_STORE_CTX *ctx);
># 363 "/usr/include/openssl/x509_vfy.h" 3 4
>X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m);
>X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void);
>X509_LOOKUP_METHOD *X509_LOOKUP_file(void);
>
>int X509_STORE_add_cert(X509_STORE *ctx, X509 *x);
>int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x);
>
>int X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
> X509_NAME *name, X509_OBJECT *ret);
>X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs,
> X509_LOOKUP_TYPE type,
> X509_NAME *name);
>
>int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc,
> long argl, char **ret);
>
>int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type);
>int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type);
>int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type);
>
>X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method);
>void X509_LOOKUP_free(X509_LOOKUP *ctx);
>int X509_LOOKUP_init(X509_LOOKUP *ctx);
>int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
> X509_NAME *name, X509_OBJECT *ret);
>int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
> X509_NAME *name, ASN1_INTEGER *serial,
> X509_OBJECT *ret);
>int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
> const unsigned char *bytes, int len,
> X509_OBJECT *ret);
>int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
> const char *str, int len, X509_OBJECT *ret);
>int X509_LOOKUP_shutdown(X509_LOOKUP *ctx);
>
>int X509_STORE_load_locations(X509_STORE *ctx,
> const char *file, const char *dir);
>int X509_STORE_set_default_paths(X509_STORE *ctx);
>
>
>
>int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data);
>void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx);
>int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx);
>void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s);
>int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx);
>void X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth);
>X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx);
>void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x);
>X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx);
>X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx);
>X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx);
>struct stack_st_X509 *X509_STORE_CTX_get0_chain(X509_STORE_CTX *ctx);
>struct stack_st_X509 *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx);
>void X509_STORE_CTX_set_cert(X509_STORE_CTX *c, X509 *x);
>void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *c, struct stack_st_X509 *sk);
>void X509_STORE_CTX_set0_crls(X509_STORE_CTX *c, struct stack_st_X509_CRL *sk);
>int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose);
>int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust);
>int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
> int purpose, int trust);
>void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags);
>void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags,
> time_t t);
>
>X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx);
>int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx);
>int X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx);
>
>X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx);
>void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param);
>int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name);
>
>
>
>
>
>void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, SSL_DANE *dane);
>
>
>
>
>X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void);
>void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param);
>int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to,
> const X509_VERIFY_PARAM *from);
>int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to,
> const X509_VERIFY_PARAM *from);
>int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name);
>int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param,
> unsigned long flags);
>int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,
> unsigned long flags);
>unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param);
>int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose);
>int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust);
>void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth);
>void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level);
>time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param);
>void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);
>int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,
> ASN1_OBJECT *policy);
>int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
> struct stack_st_ASN1_OBJECT *policies);
>
>int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param,
> uint32_t flags);
>uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param);
>
>int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
> const char *name, size_t namelen);
>int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
> const char *name, size_t namelen);
>void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
> unsigned int flags);
>char *X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *);
>void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM *, X509_VERIFY_PARAM *);
>int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,
> const char *email, size_t emaillen);
>int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
> const unsigned char *ip, size_t iplen);
>int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param,
> const char *ipasc);
>
>int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);
>int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param);
>const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param);
>
>int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param);
>int X509_VERIFY_PARAM_get_count(void);
>const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id);
>const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name);
>void X509_VERIFY_PARAM_table_cleanup(void);
># 510 "/usr/include/openssl/x509_vfy.h" 3 4
>int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy,
> struct stack_st_X509 *certs,
> struct stack_st_ASN1_OBJECT *policy_oids, unsigned int flags);
>
>void X509_policy_tree_free(X509_POLICY_TREE *tree);
>
>int X509_policy_tree_level_count(const X509_POLICY_TREE *tree);
>X509_POLICY_LEVEL *X509_policy_tree_get0_level(const X509_POLICY_TREE *tree,
> int i);
>
>struct stack_st_X509_POLICY_NODE *X509_policy_tree_get0_policies(const
> X509_POLICY_TREE
> *tree);
>
>struct stack_st_X509_POLICY_NODE *X509_policy_tree_get0_user_policies(const
> X509_POLICY_TREE
> *tree);
>
>int X509_policy_level_node_count(X509_POLICY_LEVEL *level);
>
>X509_POLICY_NODE *X509_policy_level_get0_node(X509_POLICY_LEVEL *level,
> int i);
>
>const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node);
>
>struct stack_st_POLICYQUALINFO *X509_policy_node_get0_qualifiers(const
> X509_POLICY_NODE
> *node);
>const X509_POLICY_NODE *X509_policy_node_get0_parent(const X509_POLICY_NODE
> *node);
>
>
>}
># 310 "/usr/include/openssl/x509.h" 2 3 4
># 1 "/usr/include/openssl/pkcs7.h" 1 3 4
># 21 "/usr/include/openssl/pkcs7.h" 3 4
>extern "C" {
># 31 "/usr/include/openssl/pkcs7.h" 3 4
>typedef struct pkcs7_issuer_and_serial_st {
> X509_NAME *issuer;
> ASN1_INTEGER *serial;
>} PKCS7_ISSUER_AND_SERIAL;
>
>typedef struct pkcs7_signer_info_st {
> ASN1_INTEGER *version;
> PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
> X509_ALGOR *digest_alg;
> struct stack_st_X509_ATTRIBUTE *auth_attr;
> X509_ALGOR *digest_enc_alg;
> ASN1_OCTET_STRING *enc_digest;
> struct stack_st_X509_ATTRIBUTE *unauth_attr;
>
> EVP_PKEY *pkey;
>} PKCS7_SIGNER_INFO;
>
>struct stack_st_PKCS7_SIGNER_INFO; typedef int (*sk_PKCS7_SIGNER_INFO_compfunc)(const PKCS7_SIGNER_INFO * const *a, const PKCS7_SIGNER_INFO *const *b); typedef void (*sk_PKCS7_SIGNER_INFO_freefunc)(PKCS7_SIGNER_INFO *a); typedef PKCS7_SIGNER_INFO * (*sk_PKCS7_SIGNER_INFO_copyfunc)(const PKCS7_SIGNER_INFO *a); static inline int sk_PKCS7_SIGNER_INFO_num(const struct stack_st_PKCS7_SIGNER_INFO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_value(const struct stack_st_PKCS7_SIGNER_INFO *sk, int idx) { return (PKCS7_SIGNER_INFO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_new(sk_PKCS7_SIGNER_INFO_compfunc compare) { return (struct stack_st_PKCS7_SIGNER_INFO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_new_null(void) { return (struct stack_st_PKCS7_SIGNER_INFO *)OPENSSL_sk_new_null(); } static inline void sk_PKCS7_SIGNER_INFO_free(struct stack_st_PKCS7_SIGNER_INFO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_PKCS7_SIGNER_INFO_zero(struct stack_st_PKCS7_SIGNER_INFO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_delete(struct stack_st_PKCS7_SIGNER_INFO *sk, int i) { return (PKCS7_SIGNER_INFO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_delete_ptr(struct stack_st_PKCS7_SIGNER_INFO *sk, PKCS7_SIGNER_INFO *ptr) { return (PKCS7_SIGNER_INFO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_SIGNER_INFO_push(struct stack_st_PKCS7_SIGNER_INFO *sk, PKCS7_SIGNER_INFO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_SIGNER_INFO_unshift(struct stack_st_PKCS7_SIGNER_INFO *sk, PKCS7_SIGNER_INFO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_pop(struct stack_st_PKCS7_SIGNER_INFO *sk) { return (PKCS7_SIGNER_INFO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_shift(struct stack_st_PKCS7_SIGNER_INFO *sk) { return (PKCS7_SIGNER_INFO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_PKCS7_SIGNER_INFO_pop_free(struct stack_st_PKCS7_SIGNER_INFO *sk, sk_PKCS7_SIGNER_INFO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_PKCS7_SIGNER_INFO_insert(struct stack_st_PKCS7_SIGNER_INFO *sk, PKCS7_SIGNER_INFO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_set(struct stack_st_PKCS7_SIGNER_INFO *sk, int idx, PKCS7_SIGNER_INFO *ptr) { return (PKCS7_SIGNER_INFO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_PKCS7_SIGNER_INFO_find(struct stack_st_PKCS7_SIGNER_INFO *sk, PKCS7_SIGNER_INFO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_SIGNER_INFO_find_ex(struct stack_st_PKCS7_SIGNER_INFO *sk, PKCS7_SIGNER_INFO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_PKCS7_SIGNER_INFO_sort(struct stack_st_PKCS7_SIGNER_INFO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_PKCS7_SIGNER_INFO_is_sorted(const struct stack_st_PKCS7_SIGNER_INFO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_PKCS7_SIGNER_INFO * sk_PKCS7_SIGNER_INFO_dup(const struct stack_st_PKCS7_SIGNER_INFO *sk) { return (struct stack_st_PKCS7_SIGNER_INFO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_PKCS7_SIGNER_INFO *sk_PKCS7_SIGNER_INFO_deep_copy(const struct stack_st_PKCS7_SIGNER_INFO *sk, sk_PKCS7_SIGNER_INFO_copyfunc copyfunc, sk_PKCS7_SIGNER_INFO_freefunc freefunc) { return (struct stack_st_PKCS7_SIGNER_INFO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_PKCS7_SIGNER_INFO_compfunc sk_PKCS7_SIGNER_INFO_set_cmp_func(struct stack_st_PKCS7_SIGNER_INFO *sk, sk_PKCS7_SIGNER_INFO_compfunc compare) { return (sk_PKCS7_SIGNER_INFO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct pkcs7_recip_info_st {
> ASN1_INTEGER *version;
> PKCS7_ISSUER_AND_SERIAL *issuer_and_serial;
> X509_ALGOR *key_enc_algor;
> ASN1_OCTET_STRING *enc_key;
> X509 *cert;
>} PKCS7_RECIP_INFO;
>
>struct stack_st_PKCS7_RECIP_INFO; typedef int (*sk_PKCS7_RECIP_INFO_compfunc)(const PKCS7_RECIP_INFO * const *a, const PKCS7_RECIP_INFO *const *b); typedef void (*sk_PKCS7_RECIP_INFO_freefunc)(PKCS7_RECIP_INFO *a); typedef PKCS7_RECIP_INFO * (*sk_PKCS7_RECIP_INFO_copyfunc)(const PKCS7_RECIP_INFO *a); static inline int sk_PKCS7_RECIP_INFO_num(const struct stack_st_PKCS7_RECIP_INFO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_value(const struct stack_st_PKCS7_RECIP_INFO *sk, int idx) { return (PKCS7_RECIP_INFO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_new(sk_PKCS7_RECIP_INFO_compfunc compare) { return (struct stack_st_PKCS7_RECIP_INFO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_new_null(void) { return (struct stack_st_PKCS7_RECIP_INFO *)OPENSSL_sk_new_null(); } static inline void sk_PKCS7_RECIP_INFO_free(struct stack_st_PKCS7_RECIP_INFO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_PKCS7_RECIP_INFO_zero(struct stack_st_PKCS7_RECIP_INFO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_delete(struct stack_st_PKCS7_RECIP_INFO *sk, int i) { return (PKCS7_RECIP_INFO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_delete_ptr(struct stack_st_PKCS7_RECIP_INFO *sk, PKCS7_RECIP_INFO *ptr) { return (PKCS7_RECIP_INFO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_RECIP_INFO_push(struct stack_st_PKCS7_RECIP_INFO *sk, PKCS7_RECIP_INFO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_RECIP_INFO_unshift(struct stack_st_PKCS7_RECIP_INFO *sk, PKCS7_RECIP_INFO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_pop(struct stack_st_PKCS7_RECIP_INFO *sk) { return (PKCS7_RECIP_INFO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_shift(struct stack_st_PKCS7_RECIP_INFO *sk) { return (PKCS7_RECIP_INFO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_PKCS7_RECIP_INFO_pop_free(struct stack_st_PKCS7_RECIP_INFO *sk, sk_PKCS7_RECIP_INFO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_PKCS7_RECIP_INFO_insert(struct stack_st_PKCS7_RECIP_INFO *sk, PKCS7_RECIP_INFO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_set(struct stack_st_PKCS7_RECIP_INFO *sk, int idx, PKCS7_RECIP_INFO *ptr) { return (PKCS7_RECIP_INFO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_PKCS7_RECIP_INFO_find(struct stack_st_PKCS7_RECIP_INFO *sk, PKCS7_RECIP_INFO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_RECIP_INFO_find_ex(struct stack_st_PKCS7_RECIP_INFO *sk, PKCS7_RECIP_INFO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_PKCS7_RECIP_INFO_sort(struct stack_st_PKCS7_RECIP_INFO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_PKCS7_RECIP_INFO_is_sorted(const struct stack_st_PKCS7_RECIP_INFO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_PKCS7_RECIP_INFO * sk_PKCS7_RECIP_INFO_dup(const struct stack_st_PKCS7_RECIP_INFO *sk) { return (struct stack_st_PKCS7_RECIP_INFO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_PKCS7_RECIP_INFO *sk_PKCS7_RECIP_INFO_deep_copy(const struct stack_st_PKCS7_RECIP_INFO *sk, sk_PKCS7_RECIP_INFO_copyfunc copyfunc, sk_PKCS7_RECIP_INFO_freefunc freefunc) { return (struct stack_st_PKCS7_RECIP_INFO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_PKCS7_RECIP_INFO_compfunc sk_PKCS7_RECIP_INFO_set_cmp_func(struct stack_st_PKCS7_RECIP_INFO *sk, sk_PKCS7_RECIP_INFO_compfunc compare) { return (sk_PKCS7_RECIP_INFO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct pkcs7_signed_st {
> ASN1_INTEGER *version;
> struct stack_st_X509_ALGOR *md_algs;
> struct stack_st_X509 *cert;
> struct stack_st_X509_CRL *crl;
> struct stack_st_PKCS7_SIGNER_INFO *signer_info;
> struct pkcs7_st *contents;
>} PKCS7_SIGNED;
>
>
>
>
>
>typedef struct pkcs7_enc_content_st {
> ASN1_OBJECT *content_type;
> X509_ALGOR *algorithm;
> ASN1_OCTET_STRING *enc_data;
> const EVP_CIPHER *cipher;
>} PKCS7_ENC_CONTENT;
>
>typedef struct pkcs7_enveloped_st {
> ASN1_INTEGER *version;
> struct stack_st_PKCS7_RECIP_INFO *recipientinfo;
> PKCS7_ENC_CONTENT *enc_data;
>} PKCS7_ENVELOPE;
>
>typedef struct pkcs7_signedandenveloped_st {
> ASN1_INTEGER *version;
> struct stack_st_X509_ALGOR *md_algs;
> struct stack_st_X509 *cert;
> struct stack_st_X509_CRL *crl;
> struct stack_st_PKCS7_SIGNER_INFO *signer_info;
> PKCS7_ENC_CONTENT *enc_data;
> struct stack_st_PKCS7_RECIP_INFO *recipientinfo;
>} PKCS7_SIGN_ENVELOPE;
>
>typedef struct pkcs7_digest_st {
> ASN1_INTEGER *version;
> X509_ALGOR *md;
> struct pkcs7_st *contents;
> ASN1_OCTET_STRING *digest;
>} PKCS7_DIGEST;
>
>typedef struct pkcs7_encrypted_st {
> ASN1_INTEGER *version;
> PKCS7_ENC_CONTENT *enc_data;
>} PKCS7_ENCRYPT;
>
>typedef struct pkcs7_st {
>
>
>
>
> unsigned char *asn1;
> long length;
>
>
>
> int state;
> int detached;
> ASN1_OBJECT *type;
>
>
>
>
>
> union {
> char *ptr;
>
> ASN1_OCTET_STRING *data;
>
> PKCS7_SIGNED *sign;
>
> PKCS7_ENVELOPE *enveloped;
>
> PKCS7_SIGN_ENVELOPE *signed_and_enveloped;
>
> PKCS7_DIGEST *digest;
>
> PKCS7_ENCRYPT *encrypted;
>
> ASN1_TYPE *other;
> } d;
>} PKCS7;
>
>struct stack_st_PKCS7; typedef int (*sk_PKCS7_compfunc)(const PKCS7 * const *a, const PKCS7 *const *b); typedef void (*sk_PKCS7_freefunc)(PKCS7 *a); typedef PKCS7 * (*sk_PKCS7_copyfunc)(const PKCS7 *a); static inline int sk_PKCS7_num(const struct stack_st_PKCS7 *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline PKCS7 *sk_PKCS7_value(const struct stack_st_PKCS7 *sk, int idx) { return (PKCS7 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_PKCS7 *sk_PKCS7_new(sk_PKCS7_compfunc compare) { return (struct stack_st_PKCS7 *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_PKCS7 *sk_PKCS7_new_null(void) { return (struct stack_st_PKCS7 *)OPENSSL_sk_new_null(); } static inline void sk_PKCS7_free(struct stack_st_PKCS7 *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_PKCS7_zero(struct stack_st_PKCS7 *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline PKCS7 *sk_PKCS7_delete(struct stack_st_PKCS7 *sk, int i) { return (PKCS7 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline PKCS7 *sk_PKCS7_delete_ptr(struct stack_st_PKCS7 *sk, PKCS7 *ptr) { return (PKCS7 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_push(struct stack_st_PKCS7 *sk, PKCS7 *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_unshift(struct stack_st_PKCS7 *sk, PKCS7 *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline PKCS7 *sk_PKCS7_pop(struct stack_st_PKCS7 *sk) { return (PKCS7 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline PKCS7 *sk_PKCS7_shift(struct stack_st_PKCS7 *sk) { return (PKCS7 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_PKCS7_pop_free(struct stack_st_PKCS7 *sk, sk_PKCS7_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_PKCS7_insert(struct stack_st_PKCS7 *sk, PKCS7 *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline PKCS7 *sk_PKCS7_set(struct stack_st_PKCS7 *sk, int idx, PKCS7 *ptr) { return (PKCS7 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_PKCS7_find(struct stack_st_PKCS7 *sk, PKCS7 *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_PKCS7_find_ex(struct stack_st_PKCS7 *sk, PKCS7 *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_PKCS7_sort(struct stack_st_PKCS7 *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_PKCS7_is_sorted(const struct stack_st_PKCS7 *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_PKCS7 * sk_PKCS7_dup(const struct stack_st_PKCS7 *sk) { return (struct stack_st_PKCS7 *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_PKCS7 *sk_PKCS7_deep_copy(const struct stack_st_PKCS7 *sk, sk_PKCS7_copyfunc copyfunc, sk_PKCS7_freefunc freefunc) { return (struct stack_st_PKCS7 *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_PKCS7_compfunc sk_PKCS7_set_cmp_func(struct stack_st_PKCS7 *sk, sk_PKCS7_compfunc compare) { return (sk_PKCS7_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 203 "/usr/include/openssl/pkcs7.h" 3 4
>PKCS7_ISSUER_AND_SERIAL *PKCS7_ISSUER_AND_SERIAL_new(void); void PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a); PKCS7_ISSUER_AND_SERIAL *d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, const unsigned char **in, long len); int i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out); extern const ASN1_ITEM PKCS7_ISSUER_AND_SERIAL_it;
>
>int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
> const EVP_MD *type, unsigned char *md,
> unsigned int *len);
>
>PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7);
>int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7);
>
>PKCS7 *PKCS7_dup(PKCS7 *p7);
>PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7);
>int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7);
>int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
>int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags);
>
>PKCS7_SIGNER_INFO *PKCS7_SIGNER_INFO_new(void); void PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a); PKCS7_SIGNER_INFO *d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a, const unsigned char **in, long len); int i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out); extern const ASN1_ITEM PKCS7_SIGNER_INFO_it;
>PKCS7_RECIP_INFO *PKCS7_RECIP_INFO_new(void); void PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a); PKCS7_RECIP_INFO *d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a, const unsigned char **in, long len); int i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out); extern const ASN1_ITEM PKCS7_RECIP_INFO_it;
>PKCS7_SIGNED *PKCS7_SIGNED_new(void); void PKCS7_SIGNED_free(PKCS7_SIGNED *a); PKCS7_SIGNED *d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, const unsigned char **in, long len); int i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out); extern const ASN1_ITEM PKCS7_SIGNED_it;
>PKCS7_ENC_CONTENT *PKCS7_ENC_CONTENT_new(void); void PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a); PKCS7_ENC_CONTENT *d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a, const unsigned char **in, long len); int i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out); extern const ASN1_ITEM PKCS7_ENC_CONTENT_it;
>PKCS7_ENVELOPE *PKCS7_ENVELOPE_new(void); void PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a); PKCS7_ENVELOPE *d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, const unsigned char **in, long len); int i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out); extern const ASN1_ITEM PKCS7_ENVELOPE_it;
>PKCS7_SIGN_ENVELOPE *PKCS7_SIGN_ENVELOPE_new(void); void PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a); PKCS7_SIGN_ENVELOPE *d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a, const unsigned char **in, long len); int i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out); extern const ASN1_ITEM PKCS7_SIGN_ENVELOPE_it;
>PKCS7_DIGEST *PKCS7_DIGEST_new(void); void PKCS7_DIGEST_free(PKCS7_DIGEST *a); PKCS7_DIGEST *d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, const unsigned char **in, long len); int i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out); extern const ASN1_ITEM PKCS7_DIGEST_it;
>PKCS7_ENCRYPT *PKCS7_ENCRYPT_new(void); void PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a); PKCS7_ENCRYPT *d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, const unsigned char **in, long len); int i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out); extern const ASN1_ITEM PKCS7_ENCRYPT_it;
>PKCS7 *PKCS7_new(void); void PKCS7_free(PKCS7 *a); PKCS7 *d2i_PKCS7(PKCS7 **a, const unsigned char **in, long len); int i2d_PKCS7(PKCS7 *a, unsigned char **out); extern const ASN1_ITEM PKCS7_it;
>
>extern const ASN1_ITEM PKCS7_ATTR_SIGN_it;
>extern const ASN1_ITEM PKCS7_ATTR_VERIFY_it;
>
>int i2d_PKCS7_NDEF(PKCS7 *a, unsigned char **out);
>int PKCS7_print_ctx(BIO *out, PKCS7 *x, int indent, const ASN1_PCTX *pctx);
>
>long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg);
>
>int PKCS7_set_type(PKCS7 *p7, int type);
>int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other);
>int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data);
>int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
> const EVP_MD *dgst);
>int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si);
>int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i);
>int PKCS7_add_certificate(PKCS7 *p7, X509 *x509);
>int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509);
>int PKCS7_content_new(PKCS7 *p7, int nid);
>int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx,
> BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si);
>int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si,
> X509 *x509);
>
>BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio);
>int PKCS7_dataFinal(PKCS7 *p7, BIO *bio);
>BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert);
>
>PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509,
> EVP_PKEY *pkey, const EVP_MD *dgst);
>X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si);
>int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md);
>struct stack_st_PKCS7_SIGNER_INFO *PKCS7_get_signer_info(PKCS7 *p7);
>
>PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509);
>void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
> X509_ALGOR **pdig, X509_ALGOR **psig);
>void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc);
>int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri);
>int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509);
>int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher);
>int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7);
>
>PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx);
>ASN1_OCTET_STRING *PKCS7_digest_from_attributes(struct stack_st_X509_ATTRIBUTE *sk);
>int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type,
> void *data);
>int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
> void *value);
>ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid);
>ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid);
>int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
> struct stack_st_X509_ATTRIBUTE *sk);
>int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si,
> struct stack_st_X509_ATTRIBUTE *sk);
>
>PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, struct stack_st_X509 *certs,
> BIO *data, int flags);
>
>PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7,
> X509 *signcert, EVP_PKEY *pkey,
> const EVP_MD *md, int flags);
>
>int PKCS7_final(PKCS7 *p7, BIO *data, int flags);
>int PKCS7_verify(PKCS7 *p7, struct stack_st_X509 *certs, X509_STORE *store,
> BIO *indata, BIO *out, int flags);
>struct stack_st_X509 *PKCS7_get0_signers(PKCS7 *p7, struct stack_st_X509 *certs,
> int flags);
>PKCS7 *PKCS7_encrypt(struct stack_st_X509 *certs, BIO *in, const EVP_CIPHER *cipher,
> int flags);
>int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data,
> int flags);
>
>int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
> struct stack_st_X509_ALGOR *cap);
>struct stack_st_X509_ALGOR *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si);
>int PKCS7_simple_smimecap(struct stack_st_X509_ALGOR *sk, int nid, int arg);
>
>int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid);
>int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t);
>int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si,
> const unsigned char *md, int mdlen);
>
>int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags);
>PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont);
>
>BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7);
>
>
>
>
>
>
>
>int ERR_load_PKCS7_strings(void);
># 402 "/usr/include/openssl/pkcs7.h" 3 4
>}
># 311 "/usr/include/openssl/x509.h" 2 3 4
>
>
>extern "C" {
># 323 "/usr/include/openssl/x509.h" 3 4
>void X509_CRL_set_default_method(const X509_CRL_METHOD *meth);
>X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),
> int (*crl_free) (X509_CRL *crl),
> int (*crl_lookup) (X509_CRL *crl,
> X509_REVOKED **ret,
> ASN1_INTEGER *ser,
> X509_NAME *issuer),
> int (*crl_verify) (X509_CRL *crl,
> EVP_PKEY *pk));
>void X509_CRL_METHOD_free(X509_CRL_METHOD *m);
>
>void X509_CRL_set_meth_data(X509_CRL *crl, void *dat);
>void *X509_CRL_get_meth_data(X509_CRL *crl);
>
>const char *X509_verify_cert_error_string(long n);
>
>int X509_verify(X509 *a, EVP_PKEY *r);
>
>int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r);
>int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r);
>int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r);
>
>NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len);
>char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x);
>EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x);
>int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey);
>
>int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki);
>
>int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent);
>int X509_signature_print(BIO *bp, const X509_ALGOR *alg,
> const ASN1_STRING *sig);
>
>int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
>int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx);
>
>int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert);
>
>int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md);
>int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx);
>int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md);
>int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx);
>
>int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl);
>
>int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md);
>
>int X509_pubkey_digest(const X509 *data, const EVP_MD *type,
> unsigned char *md, unsigned int *len);
>int X509_digest(const X509 *data, const EVP_MD *type,
> unsigned char *md, unsigned int *len);
>int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type,
> unsigned char *md, unsigned int *len);
>int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type,
> unsigned char *md, unsigned int *len);
>int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type,
> unsigned char *md, unsigned int *len);
>
>
>X509 *d2i_X509_fp(FILE *fp, X509 **x509);
>int i2d_X509_fp(FILE *fp, X509 *x509);
>X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl);
>int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl);
>X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req);
>int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req);
>
>RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa);
>int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa);
>RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa);
>int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa);
>RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa);
>int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa);
>
>
>DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa);
>int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa);
>DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa);
>int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa);
>
>
>EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey);
>int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey);
>EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey);
>int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey);
>
>X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8);
>int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8);
>PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp,
> PKCS8_PRIV_KEY_INFO **p8inf);
>int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf);
>int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key);
>int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey);
>EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a);
>int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey);
>EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a);
>
>
>X509 *d2i_X509_bio(BIO *bp, X509 **x509);
>int i2d_X509_bio(BIO *bp, X509 *x509);
>X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl);
>int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl);
>X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req);
>int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req);
>
>RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa);
>int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa);
>RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa);
>int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa);
>RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa);
>int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa);
>
>
>DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa);
>int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa);
>DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa);
>int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa);
>
>
>EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey);
>int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey);
>EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey);
>int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey);
>
>X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8);
>int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8);
>PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp,
> PKCS8_PRIV_KEY_INFO **p8inf);
>int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf);
>int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key);
>int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey);
>EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a);
>int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey);
>EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a);
>
>X509 *X509_dup(X509 *x509);
>X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa);
>X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex);
>X509_CRL *X509_CRL_dup(X509_CRL *crl);
>X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *rev);
>X509_REQ *X509_REQ_dup(X509_REQ *req);
>X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn);
>int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype,
> void *pval);
>void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype,
> const void **ppval, const X509_ALGOR *algor);
>void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md);
>int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b);
>
>X509_NAME *X509_NAME_dup(X509_NAME *xn);
>X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne);
>
>int X509_cmp_time(const ASN1_TIME *s, time_t *t);
>int X509_cmp_current_time(const ASN1_TIME *s);
>ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t);
>ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
> int offset_day, long offset_sec, time_t *t);
>ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj);
>
>const char *X509_get_default_cert_area(void);
>const char *X509_get_default_cert_dir(void);
>const char *X509_get_default_cert_file(void);
>const char *X509_get_default_cert_dir_env(void);
>const char *X509_get_default_cert_file_env(void);
>const char *X509_get_default_private_dir(void);
>
>X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md);
>X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey);
>
>X509_ALGOR *X509_ALGOR_new(void); void X509_ALGOR_free(X509_ALGOR *a); X509_ALGOR *d2i_X509_ALGOR(X509_ALGOR **a, const unsigned char **in, long len); int i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out); extern const ASN1_ITEM X509_ALGOR_it;
>X509_ALGORS *d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len); int i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out); extern const ASN1_ITEM X509_ALGORS_it;
>X509_VAL *X509_VAL_new(void); void X509_VAL_free(X509_VAL *a); X509_VAL *d2i_X509_VAL(X509_VAL **a, const unsigned char **in, long len); int i2d_X509_VAL(X509_VAL *a, unsigned char **out); extern const ASN1_ITEM X509_VAL_it;
>
>X509_PUBKEY *X509_PUBKEY_new(void); void X509_PUBKEY_free(X509_PUBKEY *a); X509_PUBKEY *d2i_X509_PUBKEY(X509_PUBKEY **a, const unsigned char **in, long len); int i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out); extern const ASN1_ITEM X509_PUBKEY_it;
>
>int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey);
>EVP_PKEY *X509_PUBKEY_get0(X509_PUBKEY *key);
>EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key);
>int X509_get_pubkey_parameters(EVP_PKEY *pkey, struct stack_st_X509 *chain);
>long X509_get_pathlen(X509 *x);
>int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp);
>EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length);
>
>int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp);
>RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length);
>
>
>int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp);
>DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length);
>
>
>int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp);
>EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length);
>
>
>X509_SIG *X509_SIG_new(void); void X509_SIG_free(X509_SIG *a); X509_SIG *d2i_X509_SIG(X509_SIG **a, const unsigned char **in, long len); int i2d_X509_SIG(X509_SIG *a, unsigned char **out); extern const ASN1_ITEM X509_SIG_it;
>void X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg,
> const ASN1_OCTET_STRING **pdigest);
>void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg,
> ASN1_OCTET_STRING **pdigest);
>
>X509_REQ_INFO *X509_REQ_INFO_new(void); void X509_REQ_INFO_free(X509_REQ_INFO *a); X509_REQ_INFO *d2i_X509_REQ_INFO(X509_REQ_INFO **a, const unsigned char **in, long len); int i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **out); extern const ASN1_ITEM X509_REQ_INFO_it;
>X509_REQ *X509_REQ_new(void); void X509_REQ_free(X509_REQ *a); X509_REQ *d2i_X509_REQ(X509_REQ **a, const unsigned char **in, long len); int i2d_X509_REQ(X509_REQ *a, unsigned char **out); extern const ASN1_ITEM X509_REQ_it;
>
>X509_ATTRIBUTE *X509_ATTRIBUTE_new(void); void X509_ATTRIBUTE_free(X509_ATTRIBUTE *a); X509_ATTRIBUTE *d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **a, const unsigned char **in, long len); int i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **out); extern const ASN1_ITEM X509_ATTRIBUTE_it;
>X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value);
>
>X509_EXTENSION *X509_EXTENSION_new(void); void X509_EXTENSION_free(X509_EXTENSION *a); X509_EXTENSION *d2i_X509_EXTENSION(X509_EXTENSION **a, const unsigned char **in, long len); int i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **out); extern const ASN1_ITEM X509_EXTENSION_it;
>X509_EXTENSIONS *d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len); int i2d_X509_EXTENSIONS(X509_EXTENSIONS *a, unsigned char **out); extern const ASN1_ITEM X509_EXTENSIONS_it;
>
>X509_NAME_ENTRY *X509_NAME_ENTRY_new(void); void X509_NAME_ENTRY_free(X509_NAME_ENTRY *a); X509_NAME_ENTRY *d2i_X509_NAME_ENTRY(X509_NAME_ENTRY **a, const unsigned char **in, long len); int i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **out); extern const ASN1_ITEM X509_NAME_ENTRY_it;
>
>X509_NAME *X509_NAME_new(void); void X509_NAME_free(X509_NAME *a); X509_NAME *d2i_X509_NAME(X509_NAME **a, const unsigned char **in, long len); int i2d_X509_NAME(X509_NAME *a, unsigned char **out); extern const ASN1_ITEM X509_NAME_it;
>
>int X509_NAME_set(X509_NAME **xn, X509_NAME *name);
>
>X509_CINF *X509_CINF_new(void); void X509_CINF_free(X509_CINF *a); X509_CINF *d2i_X509_CINF(X509_CINF **a, const unsigned char **in, long len); int i2d_X509_CINF(X509_CINF *a, unsigned char **out); extern const ASN1_ITEM X509_CINF_it;
>
>X509 *X509_new(void); void X509_free(X509 *a); X509 *d2i_X509(X509 **a, const unsigned char **in, long len); int i2d_X509(X509 *a, unsigned char **out); extern const ASN1_ITEM X509_it;
>X509_CERT_AUX *X509_CERT_AUX_new(void); void X509_CERT_AUX_free(X509_CERT_AUX *a); X509_CERT_AUX *d2i_X509_CERT_AUX(X509_CERT_AUX **a, const unsigned char **in, long len); int i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **out); extern const ASN1_ITEM X509_CERT_AUX_it;
>
>
>
>int X509_set_ex_data(X509 *r, int idx, void *arg);
>void *X509_get_ex_data(X509 *r, int idx);
>int i2d_X509_AUX(X509 *a, unsigned char **pp);
>X509 *d2i_X509_AUX(X509 **a, const unsigned char **pp, long length);
>
>int i2d_re_X509_tbs(X509 *x, unsigned char **pp);
>
>void X509_get0_signature(const ASN1_BIT_STRING **psig,
> const X509_ALGOR **palg, const X509 *x);
>int X509_get_signature_nid(const X509 *x);
>
>int X509_trusted(const X509 *x);
>int X509_alias_set1(X509 *x, const unsigned char *name, int len);
>int X509_keyid_set1(X509 *x, const unsigned char *id, int len);
>unsigned char *X509_alias_get0(X509 *x, int *len);
>unsigned char *X509_keyid_get0(X509 *x, int *len);
>int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *,
> int);
>int X509_TRUST_set(int *t, int trust);
>int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj);
>int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj);
>void X509_trust_clear(X509 *x);
>void X509_reject_clear(X509 *x);
>
>struct stack_st_ASN1_OBJECT *X509_get0_trust_objects(X509 *x);
>struct stack_st_ASN1_OBJECT *X509_get0_reject_objects(X509 *x);
>
>X509_REVOKED *X509_REVOKED_new(void); void X509_REVOKED_free(X509_REVOKED *a); X509_REVOKED *d2i_X509_REVOKED(X509_REVOKED **a, const unsigned char **in, long len); int i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out); extern const ASN1_ITEM X509_REVOKED_it;
>X509_CRL_INFO *X509_CRL_INFO_new(void); void X509_CRL_INFO_free(X509_CRL_INFO *a); X509_CRL_INFO *d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len); int i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out); extern const ASN1_ITEM X509_CRL_INFO_it;
>X509_CRL *X509_CRL_new(void); void X509_CRL_free(X509_CRL *a); X509_CRL *d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len); int i2d_X509_CRL(X509_CRL *a, unsigned char **out); extern const ASN1_ITEM X509_CRL_it;
>
>int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev);
>int X509_CRL_get0_by_serial(X509_CRL *crl,
> X509_REVOKED **ret, ASN1_INTEGER *serial);
>int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x);
>
>X509_PKEY *X509_PKEY_new(void);
>void X509_PKEY_free(X509_PKEY *a);
>
>NETSCAPE_SPKI *NETSCAPE_SPKI_new(void); void NETSCAPE_SPKI_free(NETSCAPE_SPKI *a); NETSCAPE_SPKI *d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **a, const unsigned char **in, long len); int i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **out); extern const ASN1_ITEM NETSCAPE_SPKI_it;
>NETSCAPE_SPKAC *NETSCAPE_SPKAC_new(void); void NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a); NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **a, const unsigned char **in, long len); int i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **out); extern const ASN1_ITEM NETSCAPE_SPKAC_it;
>NETSCAPE_CERT_SEQUENCE *NETSCAPE_CERT_SEQUENCE_new(void); void NETSCAPE_CERT_SEQUENCE_free(NETSCAPE_CERT_SEQUENCE *a); NETSCAPE_CERT_SEQUENCE *d2i_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE **a, const unsigned char **in, long len); int i2d_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE *a, unsigned char **out); extern const ASN1_ITEM NETSCAPE_CERT_SEQUENCE_it;
>
>X509_INFO *X509_INFO_new(void);
>void X509_INFO_free(X509_INFO *a);
>char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size);
>
>int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1,
> ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey);
>
>int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data,
> unsigned char *md, unsigned int *len);
>
>int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1,
> X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
> char *data, EVP_PKEY *pkey, const EVP_MD *type);
>
>int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data,
> unsigned char *md, unsigned int *len);
>
>int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1,
> ASN1_BIT_STRING *signature, void *data, EVP_PKEY *pkey);
>
>int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1,
> X509_ALGOR *algor2, ASN1_BIT_STRING *signature, void *data,
> EVP_PKEY *pkey, const EVP_MD *type);
>int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1,
> X509_ALGOR *algor2, ASN1_BIT_STRING *signature,
> void *asn, EVP_MD_CTX *ctx);
>
>long X509_get_version(const X509 *x);
>int X509_set_version(X509 *x, long version);
>int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial);
>ASN1_INTEGER *X509_get_serialNumber(X509 *x);
>const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x);
>int X509_set_issuer_name(X509 *x, X509_NAME *name);
>X509_NAME *X509_get_issuer_name(const X509 *a);
>int X509_set_subject_name(X509 *x, X509_NAME *name);
>X509_NAME *X509_get_subject_name(const X509 *a);
>const ASN1_TIME * X509_get0_notBefore(const X509 *x);
>ASN1_TIME *X509_getm_notBefore(const X509 *x);
>int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm);
>const ASN1_TIME *X509_get0_notAfter(const X509 *x);
>ASN1_TIME *X509_getm_notAfter(const X509 *x);
>int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm);
>int X509_set_pubkey(X509 *x, EVP_PKEY *pkey);
>int X509_up_ref(X509 *x);
>int X509_get_signature_type(const X509 *x);
># 646 "/usr/include/openssl/x509.h" 3 4
>X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x);
>const struct stack_st_X509_EXTENSION *X509_get0_extensions(const X509 *x);
>void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid,
> const ASN1_BIT_STRING **psuid);
>const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x);
>
>EVP_PKEY *X509_get0_pubkey(const X509 *x);
>EVP_PKEY *X509_get_pubkey(X509 *x);
>ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x);
>int X509_certificate_type(const X509 *x, const EVP_PKEY *pubkey);
>
>long X509_REQ_get_version(const X509_REQ *req);
>int X509_REQ_set_version(X509_REQ *x, long version);
>X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req);
>int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name);
>void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig,
> const X509_ALGOR **palg);
>int X509_REQ_get_signature_nid(const X509_REQ *req);
>int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp);
>int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey);
>EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req);
>EVP_PKEY *X509_REQ_get0_pubkey(X509_REQ *req);
>X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req);
>int X509_REQ_extension_nid(int nid);
>int *X509_REQ_get_extension_nids(void);
>void X509_REQ_set_extension_nids(int *nids);
>struct stack_st_X509_EXTENSION *X509_REQ_get_extensions(X509_REQ *req);
>int X509_REQ_add_extensions_nid(X509_REQ *req, struct stack_st_X509_EXTENSION *exts,
> int nid);
>int X509_REQ_add_extensions(X509_REQ *req, struct stack_st_X509_EXTENSION *exts);
>int X509_REQ_get_attr_count(const X509_REQ *req);
>int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos);
>int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
> int lastpos);
>X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc);
>X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc);
>int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr);
>int X509_REQ_add1_attr_by_OBJ(X509_REQ *req,
> const ASN1_OBJECT *obj, int type,
> const unsigned char *bytes, int len);
>int X509_REQ_add1_attr_by_NID(X509_REQ *req,
> int nid, int type,
> const unsigned char *bytes, int len);
>int X509_REQ_add1_attr_by_txt(X509_REQ *req,
> const char *attrname, int type,
> const unsigned char *bytes, int len);
>
>int X509_CRL_set_version(X509_CRL *x, long version);
>int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name);
>int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm);
>int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm);
>int X509_CRL_sort(X509_CRL *crl);
>int X509_CRL_up_ref(X509_CRL *crl);
>
>
>
>
>
>
>long X509_CRL_get_version(const X509_CRL *crl);
>const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl);
>const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl);
>ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl) __attribute__ ((deprecated));
>ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl) __attribute__ ((deprecated));
>X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl);
>const struct stack_st_X509_EXTENSION *X509_CRL_get0_extensions(const X509_CRL *crl);
>struct stack_st_X509_REVOKED *X509_CRL_get_REVOKED(X509_CRL *crl);
>void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig,
> const X509_ALGOR **palg);
>int X509_CRL_get_signature_nid(const X509_CRL *crl);
>int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp);
>
>const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x);
>int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial);
>const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x);
>int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm);
>const struct stack_st_X509_EXTENSION *
>X509_REVOKED_get0_extensions(const X509_REVOKED *r);
>
>X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer,
> EVP_PKEY *skey, const EVP_MD *md, unsigned int flags);
>
>int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey);
>
>int X509_check_private_key(const X509 *x509, const EVP_PKEY *pkey);
>int X509_chain_check_suiteb(int *perror_depth,
> X509 *x, struct stack_st_X509 *chain,
> unsigned long flags);
>int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags);
>struct stack_st_X509 *X509_chain_up_ref(struct stack_st_X509 *chain);
>
>int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b);
>unsigned long X509_issuer_and_serial_hash(X509 *a);
>
>int X509_issuer_name_cmp(const X509 *a, const X509 *b);
>unsigned long X509_issuer_name_hash(X509 *a);
>
>int X509_subject_name_cmp(const X509 *a, const X509 *b);
>unsigned long X509_subject_name_hash(X509 *x);
>
>
>unsigned long X509_issuer_name_hash_old(X509 *a);
>unsigned long X509_subject_name_hash_old(X509 *x);
>
>
>int X509_cmp(const X509 *a, const X509 *b);
>int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b);
>unsigned long X509_NAME_hash(X509_NAME *x);
>unsigned long X509_NAME_hash_old(X509_NAME *x);
>
>int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b);
>int X509_CRL_match(const X509_CRL *a, const X509_CRL *b);
>int X509_aux_print(BIO *out, X509 *x, int indent);
>
>int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag,
> unsigned long cflag);
>int X509_print_fp(FILE *bp, X509 *x);
>int X509_CRL_print_fp(FILE *bp, X509_CRL *x);
>int X509_REQ_print_fp(FILE *bp, X509_REQ *req);
>int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent,
> unsigned long flags);
>
>
>int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase);
>int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent,
> unsigned long flags);
>int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag,
> unsigned long cflag);
>int X509_print(BIO *bp, X509 *x);
>int X509_ocspid_print(BIO *bp, X509 *x);
>int X509_CRL_print(BIO *bp, X509_CRL *x);
>int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag,
> unsigned long cflag);
>int X509_REQ_print(BIO *bp, X509_REQ *req);
>
>int X509_NAME_entry_count(const X509_NAME *name);
>int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len);
>int X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj,
> char *buf, int len);
>
>
>
>
>
>int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos);
>int X509_NAME_get_index_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj,
> int lastpos);
>X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc);
>X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc);
>int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne,
> int loc, int set);
>int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
> const unsigned char *bytes, int len, int loc,
> int set);
>int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
> const unsigned char *bytes, int len, int loc,
> int set);
>X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
> const char *field, int type,
> const unsigned char *bytes,
> int len);
>X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
> int type,
> const unsigned char *bytes,
> int len);
>int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
> const unsigned char *bytes, int len, int loc,
> int set);
>X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
> const ASN1_OBJECT *obj, int type,
> const unsigned char *bytes,
> int len);
>int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj);
>int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
> const unsigned char *bytes, int len);
>ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne);
>ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne);
>int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne);
>
>int X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder,
> size_t *pderlen);
>
>int X509v3_get_ext_count(const struct stack_st_X509_EXTENSION *x);
>int X509v3_get_ext_by_NID(const struct stack_st_X509_EXTENSION *x,
> int nid, int lastpos);
>int X509v3_get_ext_by_OBJ(const struct stack_st_X509_EXTENSION *x,
> const ASN1_OBJECT *obj, int lastpos);
>int X509v3_get_ext_by_critical(const struct stack_st_X509_EXTENSION *x,
> int crit, int lastpos);
>X509_EXTENSION *X509v3_get_ext(const struct stack_st_X509_EXTENSION *x, int loc);
>X509_EXTENSION *X509v3_delete_ext(struct stack_st_X509_EXTENSION *x, int loc);
>struct stack_st_X509_EXTENSION *X509v3_add_ext(struct stack_st_X509_EXTENSION **x,
> X509_EXTENSION *ex, int loc);
>
>int X509_get_ext_count(const X509 *x);
>int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos);
>int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos);
>int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos);
>X509_EXTENSION *X509_get_ext(const X509 *x, int loc);
>X509_EXTENSION *X509_delete_ext(X509 *x, int loc);
>int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc);
>void *X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx);
>int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit,
> unsigned long flags);
>
>int X509_CRL_get_ext_count(const X509_CRL *x);
>int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos);
>int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj,
> int lastpos);
>int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos);
>X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc);
>X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc);
>int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc);
>void *X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx);
>int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
> unsigned long flags);
>
>int X509_REVOKED_get_ext_count(const X509_REVOKED *x);
>int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos);
>int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
> int lastpos);
>int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit,
> int lastpos);
>X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc);
>X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc);
>int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc);
>void *X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit,
> int *idx);
>int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
> unsigned long flags);
>
>X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex,
> int nid, int crit,
> ASN1_OCTET_STRING *data);
>X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex,
> const ASN1_OBJECT *obj, int crit,
> ASN1_OCTET_STRING *data);
>int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj);
>int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit);
>int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data);
>ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex);
>ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
>int X509_EXTENSION_get_critical(const X509_EXTENSION *ex);
>
>int X509at_get_attr_count(const struct stack_st_X509_ATTRIBUTE *x);
>int X509at_get_attr_by_NID(const struct stack_st_X509_ATTRIBUTE *x, int nid,
> int lastpos);
>int X509at_get_attr_by_OBJ(const struct stack_st_X509_ATTRIBUTE *sk,
> const ASN1_OBJECT *obj, int lastpos);
>X509_ATTRIBUTE *X509at_get_attr(const struct stack_st_X509_ATTRIBUTE *x, int loc);
>X509_ATTRIBUTE *X509at_delete_attr(struct stack_st_X509_ATTRIBUTE *x, int loc);
>struct stack_st_X509_ATTRIBUTE *X509at_add1_attr(struct stack_st_X509_ATTRIBUTE **x,
> X509_ATTRIBUTE *attr);
>struct stack_st_X509_ATTRIBUTE *X509at_add1_attr_by_OBJ(struct stack_st_X509_ATTRIBUTE
> **x, const ASN1_OBJECT *obj,
> int type,
> const unsigned char *bytes,
> int len);
>struct stack_st_X509_ATTRIBUTE *X509at_add1_attr_by_NID(struct stack_st_X509_ATTRIBUTE
> **x, int nid, int type,
> const unsigned char *bytes,
> int len);
>struct stack_st_X509_ATTRIBUTE *X509at_add1_attr_by_txt(struct stack_st_X509_ATTRIBUTE
> **x, const char *attrname,
> int type,
> const unsigned char *bytes,
> int len);
>void *X509at_get0_data_by_OBJ(struct stack_st_X509_ATTRIBUTE *x,
> const ASN1_OBJECT *obj, int lastpos, int type);
>X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
> int atrtype, const void *data,
> int len);
>X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
> const ASN1_OBJECT *obj,
> int atrtype, const void *data,
> int len);
>X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
> const char *atrname, int type,
> const unsigned char *bytes,
> int len);
>int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj);
>int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
> const void *data, int len);
>void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype,
> void *data);
>int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr);
>ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr);
>ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx);
>
>int EVP_PKEY_get_attr_count(const EVP_PKEY *key);
>int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos);
>int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj,
> int lastpos);
>X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc);
>X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc);
>int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr);
>int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key,
> const ASN1_OBJECT *obj, int type,
> const unsigned char *bytes, int len);
>int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key,
> int nid, int type,
> const unsigned char *bytes, int len);
>int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key,
> const char *attrname, int type,
> const unsigned char *bytes, int len);
>
>int X509_verify_cert(X509_STORE_CTX *ctx);
>
>
>X509 *X509_find_by_issuer_and_serial(struct stack_st_X509 *sk, X509_NAME *name,
> ASN1_INTEGER *serial);
>X509 *X509_find_by_subject(struct stack_st_X509 *sk, X509_NAME *name);
>
>PBEPARAM *PBEPARAM_new(void); void PBEPARAM_free(PBEPARAM *a); PBEPARAM *d2i_PBEPARAM(PBEPARAM **a, const unsigned char **in, long len); int i2d_PBEPARAM(PBEPARAM *a, unsigned char **out); extern const ASN1_ITEM PBEPARAM_it;
>PBE2PARAM *PBE2PARAM_new(void); void PBE2PARAM_free(PBE2PARAM *a); PBE2PARAM *d2i_PBE2PARAM(PBE2PARAM **a, const unsigned char **in, long len); int i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **out); extern const ASN1_ITEM PBE2PARAM_it;
>PBKDF2PARAM *PBKDF2PARAM_new(void); void PBKDF2PARAM_free(PBKDF2PARAM *a); PBKDF2PARAM *d2i_PBKDF2PARAM(PBKDF2PARAM **a, const unsigned char **in, long len); int i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **out); extern const ASN1_ITEM PBKDF2PARAM_it;
>
>int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
> const unsigned char *salt, int saltlen);
>
>X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
> const unsigned char *salt, int saltlen);
>X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter,
> unsigned char *salt, int saltlen);
>X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
> unsigned char *salt, int saltlen,
> unsigned char *aiv, int prf_nid);
>
>
>X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
> const unsigned char *salt, int saltlen,
> unsigned char *aiv, uint64_t N, uint64_t r,
> uint64_t p);
>
>
>X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
> int prf_nid, int keylen);
>
>
>
>PKCS8_PRIV_KEY_INFO *PKCS8_PRIV_KEY_INFO_new(void); void PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO *a); PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO **a, const unsigned char **in, long len); int i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO *a, unsigned char **out); extern const ASN1_ITEM PKCS8_PRIV_KEY_INFO_it;
>
>EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8);
>PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey);
>
>int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
> int version, int ptype, void *pval,
> unsigned char *penc, int penclen);
>int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg,
> const unsigned char **pk, int *ppklen,
> const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8);
>
>const struct stack_st_X509_ATTRIBUTE *
>PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8);
>int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type,
> const unsigned char *bytes, int len);
>
>int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
> int ptype, void *pval,
> unsigned char *penc, int penclen);
>int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg,
> const unsigned char **pk, int *ppklen,
> X509_ALGOR **pa, X509_PUBKEY *pub);
>
>int X509_check_trust(X509 *x, int id, int flags);
>int X509_TRUST_get_count(void);
>X509_TRUST *X509_TRUST_get0(int idx);
>int X509_TRUST_get_by_id(int id);
>int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int),
> const char *name, int arg1, void *arg2);
>void X509_TRUST_cleanup(void);
>int X509_TRUST_get_flags(const X509_TRUST *xp);
>char *X509_TRUST_get0_name(const X509_TRUST *xp);
>int X509_TRUST_get_trust(const X509_TRUST *xp);
>
>
>
>
>
>
>
>int ERR_load_X509_strings(void);
># 1121 "/usr/include/openssl/x509.h" 3 4
>}
># 51 "/usr/include/openssl/ssl.h" 2 3 4
>
>
>
>
># 1 "/usr/include/openssl/pem.h" 1 3 4
># 18 "/usr/include/openssl/pem.h" 3 4
># 1 "/usr/include/openssl/pem2.h" 1 3 4
># 11 "/usr/include/openssl/pem2.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
>}
># 19 "/usr/include/openssl/pem.h" 2 3 4
>
>
>extern "C" {
># 57 "/usr/include/openssl/pem.h" 3 4
>typedef struct pem_recip_st {
> char *name;
> X509_NAME *dn;
> int cipher;
> int key_enc;
>
>} PEM_USER;
>
>typedef struct pem_ctx_st {
> int type;
> struct {
> int version;
> int mode;
> } proc_type;
>
> char *domain;
>
> struct {
> int cipher;
>
>
>
> } DEK_info;
>
> PEM_USER *originator;
>
> int num_recipient;
> PEM_USER **recipient;
>
>
>
>
> EVP_MD *md;
>
> int md_enc;
> int md_len;
> char *md_data;
>
> EVP_CIPHER *dec;
> int key_len;
> unsigned char *key;
>
>
>
>
> int data_enc;
> int data_len;
> unsigned char *data;
>} PEM_CTX;
># 281 "/usr/include/openssl/pem.h" 3 4
>typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata);
>
>int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
>int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len,
> pem_password_cb *callback, void *u);
>
>int PEM_read_bio(BIO *bp, char **name, char **header,
> unsigned char **data, long *len);
>int PEM_write_bio(BIO *bp, const char *name, const char *hdr,
> const unsigned char *data, long len);
>int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
> const char *name, BIO *bp, pem_password_cb *cb,
> void *u);
>void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
> pem_password_cb *cb, void *u);
>int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x,
> const EVP_CIPHER *enc, unsigned char *kstr, int klen,
> pem_password_cb *cb, void *u);
>
>struct stack_st_X509_INFO *PEM_X509_INFO_read_bio(BIO *bp, struct stack_st_X509_INFO *sk,
> pem_password_cb *cb, void *u);
>int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc,
> unsigned char *kstr, int klen,
> pem_password_cb *cd, void *u);
>
>
>int PEM_read(FILE *fp, char **name, char **header,
> unsigned char **data, long *len);
>int PEM_write(FILE *fp, const char *name, const char *hdr,
> const unsigned char *data, long len);
>void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
> pem_password_cb *cb, void *u);
>int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
> void *x, const EVP_CIPHER *enc, unsigned char *kstr,
> int klen, pem_password_cb *callback, void *u);
>struct stack_st_X509_INFO *PEM_X509_INFO_read(FILE *fp, struct stack_st_X509_INFO *sk,
> pem_password_cb *cb, void *u);
>
>
>int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
>int PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *d, unsigned int cnt);
>int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
> unsigned int *siglen, EVP_PKEY *pkey);
>
>int PEM_def_callback(char *buf, int num, int w, void *key);
>void PEM_proc_type(char *buf, int type);
>void PEM_dek_info(char *buf, const char *type, int len, char *str);
>
>
>
>X509 *PEM_read_bio_X509(BIO *bp, X509 **x, pem_password_cb *cb, void *u); X509 *PEM_read_X509(FILE *fp, X509 **x, pem_password_cb *cb, void *u); int PEM_write_bio_X509(BIO *bp, X509 *x); int PEM_write_X509(FILE *fp, X509 *x);
>X509 *PEM_read_bio_X509_AUX(BIO *bp, X509 **x, pem_password_cb *cb, void *u); X509 *PEM_read_X509_AUX(FILE *fp, X509 **x, pem_password_cb *cb, void *u); int PEM_write_bio_X509_AUX(BIO *bp, X509 *x); int PEM_write_X509_AUX(FILE *fp, X509 *x);
>X509_REQ *PEM_read_bio_X509_REQ(BIO *bp, X509_REQ **x, pem_password_cb *cb, void *u); X509_REQ *PEM_read_X509_REQ(FILE *fp, X509_REQ **x, pem_password_cb *cb, void *u); int PEM_write_bio_X509_REQ(BIO *bp, X509_REQ *x); int PEM_write_X509_REQ(FILE *fp, X509_REQ *x);
>int PEM_write_bio_X509_REQ_NEW(BIO *bp, X509_REQ *x); int PEM_write_X509_REQ_NEW(FILE *fp, X509_REQ *x);
>X509_CRL *PEM_read_bio_X509_CRL(BIO *bp, X509_CRL **x, pem_password_cb *cb, void *u); X509_CRL *PEM_read_X509_CRL(FILE *fp, X509_CRL **x, pem_password_cb *cb, void *u); int PEM_write_bio_X509_CRL(BIO *bp, X509_CRL *x); int PEM_write_X509_CRL(FILE *fp, X509_CRL *x);
>PKCS7 *PEM_read_bio_PKCS7(BIO *bp, PKCS7 **x, pem_password_cb *cb, void *u); PKCS7 *PEM_read_PKCS7(FILE *fp, PKCS7 **x, pem_password_cb *cb, void *u); int PEM_write_bio_PKCS7(BIO *bp, PKCS7 *x); int PEM_write_PKCS7(FILE *fp, PKCS7 *x);
>NETSCAPE_CERT_SEQUENCE *PEM_read_bio_NETSCAPE_CERT_SEQUENCE(BIO *bp, NETSCAPE_CERT_SEQUENCE **x, pem_password_cb *cb, void *u); NETSCAPE_CERT_SEQUENCE *PEM_read_NETSCAPE_CERT_SEQUENCE(FILE *fp, NETSCAPE_CERT_SEQUENCE **x, pem_password_cb *cb, void *u); int PEM_write_bio_NETSCAPE_CERT_SEQUENCE(BIO *bp, NETSCAPE_CERT_SEQUENCE *x); int PEM_write_NETSCAPE_CERT_SEQUENCE(FILE *fp, NETSCAPE_CERT_SEQUENCE *x);
>X509_SIG *PEM_read_bio_PKCS8(BIO *bp, X509_SIG **x, pem_password_cb *cb, void *u); X509_SIG *PEM_read_PKCS8(FILE *fp, X509_SIG **x, pem_password_cb *cb, void *u); int PEM_write_bio_PKCS8(BIO *bp, X509_SIG *x); int PEM_write_PKCS8(FILE *fp, X509_SIG *x);
>PKCS8_PRIV_KEY_INFO *PEM_read_bio_PKCS8_PRIV_KEY_INFO(BIO *bp, PKCS8_PRIV_KEY_INFO **x, pem_password_cb *cb, void *u); PKCS8_PRIV_KEY_INFO *PEM_read_PKCS8_PRIV_KEY_INFO(FILE *fp, PKCS8_PRIV_KEY_INFO **x, pem_password_cb *cb, void *u); int PEM_write_bio_PKCS8_PRIV_KEY_INFO(BIO *bp, PKCS8_PRIV_KEY_INFO *x); int PEM_write_PKCS8_PRIV_KEY_INFO(FILE *fp, PKCS8_PRIV_KEY_INFO *x);
>
>RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x, pem_password_cb *cb, void *u); RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **x, pem_password_cb *cb, void *u); int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u); int PEM_write_RSAPrivateKey(FILE *fp, RSA *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
>RSA *PEM_read_bio_RSAPublicKey(BIO *bp, RSA **x, pem_password_cb *cb, void *u); RSA *PEM_read_RSAPublicKey(FILE *fp, RSA **x, pem_password_cb *cb, void *u); int PEM_write_bio_RSAPublicKey(BIO *bp, const RSA *x); int PEM_write_RSAPublicKey(FILE *fp, const RSA *x);
>RSA *PEM_read_bio_RSA_PUBKEY(BIO *bp, RSA **x, pem_password_cb *cb, void *u); RSA *PEM_read_RSA_PUBKEY(FILE *fp, RSA **x, pem_password_cb *cb, void *u); int PEM_write_bio_RSA_PUBKEY(BIO *bp, RSA *x); int PEM_write_RSA_PUBKEY(FILE *fp, RSA *x);
>
>
>DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **x, pem_password_cb *cb, void *u); DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **x, pem_password_cb *cb, void *u); int PEM_write_bio_DSAPrivateKey(BIO *bp, DSA *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u); int PEM_write_DSAPrivateKey(FILE *fp, DSA *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
>DSA *PEM_read_bio_DSA_PUBKEY(BIO *bp, DSA **x, pem_password_cb *cb, void *u); DSA *PEM_read_DSA_PUBKEY(FILE *fp, DSA **x, pem_password_cb *cb, void *u); int PEM_write_bio_DSA_PUBKEY(BIO *bp, DSA *x); int PEM_write_DSA_PUBKEY(FILE *fp, DSA *x);
>DSA *PEM_read_bio_DSAparams(BIO *bp, DSA **x, pem_password_cb *cb, void *u); DSA *PEM_read_DSAparams(FILE *fp, DSA **x, pem_password_cb *cb, void *u); int PEM_write_bio_DSAparams(BIO *bp, const DSA *x); int PEM_write_DSAparams(FILE *fp, const DSA *x);
>
>
>EC_GROUP *PEM_read_bio_ECPKParameters(BIO *bp, EC_GROUP **x, pem_password_cb *cb, void *u); EC_GROUP *PEM_read_ECPKParameters(FILE *fp, EC_GROUP **x, pem_password_cb *cb, void *u); int PEM_write_bio_ECPKParameters(BIO *bp, const EC_GROUP *x); int PEM_write_ECPKParameters(FILE *fp, const EC_GROUP *x);
>EC_KEY *PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **x, pem_password_cb *cb, void *u); EC_KEY *PEM_read_ECPrivateKey(FILE *fp, EC_KEY **x, pem_password_cb *cb, void *u); int PEM_write_bio_ECPrivateKey(BIO *bp, EC_KEY *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u); int PEM_write_ECPrivateKey(FILE *fp, EC_KEY *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
>EC_KEY *PEM_read_bio_EC_PUBKEY(BIO *bp, EC_KEY **x, pem_password_cb *cb, void *u); EC_KEY *PEM_read_EC_PUBKEY(FILE *fp, EC_KEY **x, pem_password_cb *cb, void *u); int PEM_write_bio_EC_PUBKEY(BIO *bp, EC_KEY *x); int PEM_write_EC_PUBKEY(FILE *fp, EC_KEY *x);
>
>
>DH *PEM_read_bio_DHparams(BIO *bp, DH **x, pem_password_cb *cb, void *u); DH *PEM_read_DHparams(FILE *fp, DH **x, pem_password_cb *cb, void *u); int PEM_write_bio_DHparams(BIO *bp, const DH *x); int PEM_write_DHparams(FILE *fp, const DH *x);
>int PEM_write_bio_DHxparams(BIO *bp, const DH *x); int PEM_write_DHxparams(FILE *fp, const DH *x);
>
>EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u); EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u); int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u); int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
>EVP_PKEY *PEM_read_bio_PUBKEY(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u); EVP_PKEY *PEM_read_PUBKEY(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u); int PEM_write_bio_PUBKEY(BIO *bp, EVP_PKEY *x); int PEM_write_PUBKEY(FILE *fp, EVP_PKEY *x);
>
>int PEM_write_bio_PrivateKey_traditional(BIO *bp, EVP_PKEY *x,
> const EVP_CIPHER *enc,
> unsigned char *kstr, int klen,
> pem_password_cb *cb, void *u);
>
>int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
> char *kstr, int klen,
> pem_password_cb *cb, void *u);
>int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *,
> char *, int, pem_password_cb *, void *);
>int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
> char *kstr, int klen,
> pem_password_cb *cb, void *u);
>int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
> char *kstr, int klen,
> pem_password_cb *cb, void *u);
>EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
> void *u);
>
>
>int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
> char *kstr, int klen,
> pem_password_cb *cb, void *u);
>int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,
> char *kstr, int klen,
> pem_password_cb *cb, void *u);
>int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
> char *kstr, int klen,
> pem_password_cb *cb, void *u);
>
>EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
> void *u);
>
>int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
> char *kstr, int klen, pem_password_cb *cd,
> void *u);
>
>EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x);
>int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x);
>
>
>EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length);
>EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length);
>EVP_PKEY *b2i_PrivateKey_bio(BIO *in);
>EVP_PKEY *b2i_PublicKey_bio(BIO *in);
>int i2b_PrivateKey_bio(BIO *out, EVP_PKEY *pk);
>int i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk);
>
>EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u);
>int i2b_PVK_bio(BIO *out, EVP_PKEY *pk, int enclevel,
> pem_password_cb *cb, void *u);
># 422 "/usr/include/openssl/pem.h" 3 4
>int ERR_load_PEM_strings(void);
># 499 "/usr/include/openssl/pem.h" 3 4
>}
># 56 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/hmac.h" 1 3 4
># 13 "/usr/include/openssl/hmac.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/hmac.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
>
>
>size_t HMAC_size(const HMAC_CTX *e);
>HMAC_CTX *HMAC_CTX_new(void);
>int HMAC_CTX_reset(HMAC_CTX *ctx);
>void HMAC_CTX_free(HMAC_CTX *ctx);
>
>int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md) __attribute__ ((deprecated));
>
>
> int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
> const EVP_MD *md, ENGINE *impl);
> int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data,
> size_t len);
> int HMAC_Final(HMAC_CTX *ctx, unsigned char *md,
> unsigned int *len);
>unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len,
> const unsigned char *d, size_t n, unsigned char *md,
> unsigned int *md_len);
> int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx);
>
>void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags);
>const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
>
>
>}
># 57 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/async.h" 1 3 4
># 10 "/usr/include/openssl/async.h" 3 4
># 1 "/usr/include/c++/8/stdlib.h" 1 3 4
># 11 "/usr/include/openssl/async.h" 2 3 4
># 28 "/usr/include/openssl/async.h" 3 4
>extern "C" {
>
>
>typedef struct async_job_st ASYNC_JOB;
>typedef struct async_wait_ctx_st ASYNC_WAIT_CTX;
>
>
>
>
>
>
>int ASYNC_init_thread(size_t max_size, size_t init_size);
>void ASYNC_cleanup_thread(void);
>
>
>ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void);
>void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx);
>int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
> int fd,
> void *custom_data,
> void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
> int, void *));
>int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
> int *fd, void **custom_data);
>int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, int *fd,
> size_t *numfds);
>int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, int *addfd,
> size_t *numaddfds, int *delfd,
> size_t *numdelfds);
>int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key);
>
>
>int ASYNC_is_capable(void);
>
>int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret,
> int (*func)(void *), void *args, size_t size);
>int ASYNC_pause_job(void);
>
>ASYNC_JOB *ASYNC_get_current_job(void);
>ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job);
>void ASYNC_block_pause(void);
>void ASYNC_unblock_pause(void);
>
>
>
>
>
>
>
>int ERR_load_ASYNC_strings(void);
># 96 "/usr/include/openssl/async.h" 3 4
>}
># 58 "/usr/include/openssl/ssl.h" 2 3 4
>
>
>
># 1 "/usr/include/openssl/ct.h" 1 3 4
># 13 "/usr/include/openssl/ct.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/ct.h" 2 3 4
>
>
>
>
>
>
>extern "C" {
># 30 "/usr/include/openssl/ct.h" 3 4
>typedef enum {
> CT_LOG_ENTRY_TYPE_NOT_SET = -1,
> CT_LOG_ENTRY_TYPE_X509 = 0,
> CT_LOG_ENTRY_TYPE_PRECERT = 1
>} ct_log_entry_type_t;
>
>typedef enum {
> SCT_VERSION_NOT_SET = -1,
> SCT_VERSION_V1 = 0
>} sct_version_t;
>
>typedef enum {
> SCT_SOURCE_UNKNOWN,
> SCT_SOURCE_TLS_EXTENSION,
> SCT_SOURCE_X509V3_EXTENSION,
> SCT_SOURCE_OCSP_STAPLED_RESPONSE
>} sct_source_t;
>
>typedef enum {
> SCT_VALIDATION_STATUS_NOT_SET,
> SCT_VALIDATION_STATUS_UNKNOWN_LOG,
> SCT_VALIDATION_STATUS_VALID,
> SCT_VALIDATION_STATUS_INVALID,
> SCT_VALIDATION_STATUS_UNVERIFIED,
> SCT_VALIDATION_STATUS_UNKNOWN_VERSION
>} sct_validation_status_t;
>
>struct stack_st_SCT; typedef int (*sk_SCT_compfunc)(const SCT * const *a, const SCT *const *b); typedef void (*sk_SCT_freefunc)(SCT *a); typedef SCT * (*sk_SCT_copyfunc)(const SCT *a); static inline int sk_SCT_num(const struct stack_st_SCT *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline SCT *sk_SCT_value(const struct stack_st_SCT *sk, int idx) { return (SCT *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_SCT *sk_SCT_new(sk_SCT_compfunc compare) { return (struct stack_st_SCT *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_SCT *sk_SCT_new_null(void) { return (struct stack_st_SCT *)OPENSSL_sk_new_null(); } static inline void sk_SCT_free(struct stack_st_SCT *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_SCT_zero(struct stack_st_SCT *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline SCT *sk_SCT_delete(struct stack_st_SCT *sk, int i) { return (SCT *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline SCT *sk_SCT_delete_ptr(struct stack_st_SCT *sk, SCT *ptr) { return (SCT *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SCT_push(struct stack_st_SCT *sk, SCT *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SCT_unshift(struct stack_st_SCT *sk, SCT *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline SCT *sk_SCT_pop(struct stack_st_SCT *sk) { return (SCT *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline SCT *sk_SCT_shift(struct stack_st_SCT *sk) { return (SCT *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_SCT_pop_free(struct stack_st_SCT *sk, sk_SCT_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_SCT_insert(struct stack_st_SCT *sk, SCT *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline SCT *sk_SCT_set(struct stack_st_SCT *sk, int idx, SCT *ptr) { return (SCT *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_SCT_find(struct stack_st_SCT *sk, SCT *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SCT_find_ex(struct stack_st_SCT *sk, SCT *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_SCT_sort(struct stack_st_SCT *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_SCT_is_sorted(const struct stack_st_SCT *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_SCT * sk_SCT_dup(const struct stack_st_SCT *sk) { return (struct stack_st_SCT *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_SCT *sk_SCT_deep_copy(const struct stack_st_SCT *sk, sk_SCT_copyfunc copyfunc, sk_SCT_freefunc freefunc) { return (struct stack_st_SCT *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_SCT_compfunc sk_SCT_set_cmp_func(struct stack_st_SCT *sk, sk_SCT_compfunc compare) { return (sk_SCT_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct stack_st_CTLOG; typedef int (*sk_CTLOG_compfunc)(const CTLOG * const *a, const CTLOG *const *b); typedef void (*sk_CTLOG_freefunc)(CTLOG *a); typedef CTLOG * (*sk_CTLOG_copyfunc)(const CTLOG *a); static inline int sk_CTLOG_num(const struct stack_st_CTLOG *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline CTLOG *sk_CTLOG_value(const struct stack_st_CTLOG *sk, int idx) { return (CTLOG *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_CTLOG *sk_CTLOG_new(sk_CTLOG_compfunc compare) { return (struct stack_st_CTLOG *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_CTLOG *sk_CTLOG_new_null(void) { return (struct stack_st_CTLOG *)OPENSSL_sk_new_null(); } static inline void sk_CTLOG_free(struct stack_st_CTLOG *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_CTLOG_zero(struct stack_st_CTLOG *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline CTLOG *sk_CTLOG_delete(struct stack_st_CTLOG *sk, int i) { return (CTLOG *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline CTLOG *sk_CTLOG_delete_ptr(struct stack_st_CTLOG *sk, CTLOG *ptr) { return (CTLOG *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CTLOG_push(struct stack_st_CTLOG *sk, CTLOG *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CTLOG_unshift(struct stack_st_CTLOG *sk, CTLOG *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline CTLOG *sk_CTLOG_pop(struct stack_st_CTLOG *sk) { return (CTLOG *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline CTLOG *sk_CTLOG_shift(struct stack_st_CTLOG *sk) { return (CTLOG *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_CTLOG_pop_free(struct stack_st_CTLOG *sk, sk_CTLOG_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_CTLOG_insert(struct stack_st_CTLOG *sk, CTLOG *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline CTLOG *sk_CTLOG_set(struct stack_st_CTLOG *sk, int idx, CTLOG *ptr) { return (CTLOG *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_CTLOG_find(struct stack_st_CTLOG *sk, CTLOG *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_CTLOG_find_ex(struct stack_st_CTLOG *sk, CTLOG *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_CTLOG_sort(struct stack_st_CTLOG *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_CTLOG_is_sorted(const struct stack_st_CTLOG *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_CTLOG * sk_CTLOG_dup(const struct stack_st_CTLOG *sk) { return (struct stack_st_CTLOG *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_CTLOG *sk_CTLOG_deep_copy(const struct stack_st_CTLOG *sk, sk_CTLOG_copyfunc copyfunc, sk_CTLOG_freefunc freefunc) { return (struct stack_st_CTLOG *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_CTLOG_compfunc sk_CTLOG_set_cmp_func(struct stack_st_CTLOG *sk, sk_CTLOG_compfunc compare) { return (sk_CTLOG_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 69 "/usr/include/openssl/ct.h" 3 4
>CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void);
>
>
>void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx);
>
>
>X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx);
>
>
>
>
>
>
>int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert);
>
>
>X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx);
>
>
>
>
>
>
>int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer);
>
>
>const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx);
>
>
>void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx,
> CTLOG_STORE *log_store);
>
>
>
>
>
>
>uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx);
>
>
>
>
>
>
>
>void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms);
># 124 "/usr/include/openssl/ct.h" 3 4
>SCT *SCT_new(void);
>
>
>
>
>
>SCT *SCT_new_from_base64(unsigned char version,
> const char *logid_base64,
> ct_log_entry_type_t entry_type,
> uint64_t timestamp,
> const char *extensions_base64,
> const char *signature_base64);
>
>
>
>
>void SCT_free(SCT *sct);
>
>
>
>
>
>void SCT_LIST_free(struct stack_st_SCT *a);
>
>
>
>
>sct_version_t SCT_get_version(const SCT *sct);
>
>
>
>
>
> int SCT_set_version(SCT *sct, sct_version_t version);
>
>
>
>
>ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct);
>
>
>
>
>
> int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type);
>
>
>
>
>
>
>size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id);
>
>
>
>
>
>
> int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len);
>
>
>
>
>
>
> int SCT_set1_log_id(SCT *sct, const unsigned char *log_id,
> size_t log_id_len);
>
>
>
>
>uint64_t SCT_get_timestamp(const SCT *sct);
>
>
>
>
>void SCT_set_timestamp(SCT *sct, uint64_t timestamp);
>
>
>
>
>
>
>int SCT_get_signature_nid(const SCT *sct);
>
>
>
>
>
>
>
> int SCT_set_signature_nid(SCT *sct, int nid);
>
>
>
>
>
>
>size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext);
>
>
>
>
>
>void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len);
>
>
>
>
>
>
> int SCT_set1_extensions(SCT *sct, const unsigned char *ext,
> size_t ext_len);
>
>
>
>
>
>
>size_t SCT_get0_signature(const SCT *sct, unsigned char **sig);
>
>
>
>
>
>void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len);
>
>
>
>
>
> int SCT_set1_signature(SCT *sct, const unsigned char *sig,
> size_t sig_len);
>
>
>
>
>sct_source_t SCT_get_source(const SCT *sct);
>
>
>
>
>
> int SCT_set_source(SCT *sct, sct_source_t source);
>
>
>
>
>const char *SCT_validation_status_string(const SCT *sct);
>
>
>
>
>
>
>
>void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs);
># 289 "/usr/include/openssl/ct.h" 3 4
>void SCT_LIST_print(const struct stack_st_SCT *sct_list, BIO *out, int indent,
> const char *separator, const CTLOG_STORE *logs);
>
>
>
>
>
>sct_validation_status_t SCT_get_validation_status(const SCT *sct);
># 305 "/usr/include/openssl/ct.h" 3 4
> int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx);
># 314 "/usr/include/openssl/ct.h" 3 4
> int SCT_LIST_validate(const struct stack_st_SCT *scts,
> CT_POLICY_EVAL_CTX *ctx);
># 334 "/usr/include/openssl/ct.h" 3 4
> int i2o_SCT_LIST(const struct stack_st_SCT *a, unsigned char **pp);
># 346 "/usr/include/openssl/ct.h" 3 4
>struct stack_st_SCT *o2i_SCT_LIST(struct stack_st_SCT **a, const unsigned char **pp,
> size_t len);
># 361 "/usr/include/openssl/ct.h" 3 4
> int i2d_SCT_LIST(const struct stack_st_SCT *a, unsigned char **pp);
># 373 "/usr/include/openssl/ct.h" 3 4
>struct stack_st_SCT *d2i_SCT_LIST(struct stack_st_SCT **a, const unsigned char **pp,
> long len);
># 385 "/usr/include/openssl/ct.h" 3 4
> int i2o_SCT(const SCT *sct, unsigned char **out);
># 398 "/usr/include/openssl/ct.h" 3 4
>SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len);
># 410 "/usr/include/openssl/ct.h" 3 4
>CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name);
>
>
>
>
>
>
>
>int CTLOG_new_from_base64(CTLOG ** ct_log,
> const char *pkey_base64, const char *name);
>
>
>
>
>void CTLOG_free(CTLOG *log);
>
>
>const char *CTLOG_get0_name(const CTLOG *log);
>
>void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id,
> size_t *log_id_len);
>
>EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log);
># 442 "/usr/include/openssl/ct.h" 3 4
>CTLOG_STORE *CTLOG_STORE_new(void);
>
>
>
>
>void CTLOG_STORE_free(CTLOG_STORE *store);
>
>
>
>
>
>const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store,
> const uint8_t *log_id,
> size_t log_id_len);
>
>
>
>
>
> int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file);
>
>
>
>
>
>
>
> int CTLOG_STORE_load_default_file(CTLOG_STORE *store);
>
>
>
>
>
>
>
>int ERR_load_CT_strings(void);
># 530 "/usr/include/openssl/ct.h" 3 4
>}
># 62 "/usr/include/openssl/ssl.h" 2 3 4
>
>
>extern "C" {
># 215 "/usr/include/openssl/ssl.h" 3 4
>}
>
>
>
>extern "C" {
># 229 "/usr/include/openssl/ssl.h" 3 4
>typedef struct ssl_st *ssl_crock_st;
>typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;
>typedef struct ssl_method_st SSL_METHOD;
>typedef struct ssl_cipher_st SSL_CIPHER;
>typedef struct ssl_session_st SSL_SESSION;
>typedef struct tls_sigalgs_st TLS_SIGALGS;
>typedef struct ssl_conf_ctx_st SSL_CONF_CTX;
>typedef struct ssl_comp_st SSL_COMP;
>
>struct stack_st_SSL_CIPHER;
>struct stack_st_SSL_COMP;
>
>
>typedef struct srtp_protection_profile_st {
> const char *name;
> unsigned long id;
>} SRTP_PROTECTION_PROFILE;
>
>struct stack_st_SRTP_PROTECTION_PROFILE; typedef int (*sk_SRTP_PROTECTION_PROFILE_compfunc)(const SRTP_PROTECTION_PROFILE * const *a, const SRTP_PROTECTION_PROFILE *const *b); typedef void (*sk_SRTP_PROTECTION_PROFILE_freefunc)(SRTP_PROTECTION_PROFILE *a); typedef SRTP_PROTECTION_PROFILE * (*sk_SRTP_PROTECTION_PROFILE_copyfunc)(const SRTP_PROTECTION_PROFILE *a); static inline int sk_SRTP_PROTECTION_PROFILE_num(const struct stack_st_SRTP_PROTECTION_PROFILE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_value(const struct stack_st_SRTP_PROTECTION_PROFILE *sk, int idx) { return (SRTP_PROTECTION_PROFILE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_new(sk_SRTP_PROTECTION_PROFILE_compfunc compare) { return (struct stack_st_SRTP_PROTECTION_PROFILE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_new_null(void) { return (struct stack_st_SRTP_PROTECTION_PROFILE *)OPENSSL_sk_new_null(); } static inline void sk_SRTP_PROTECTION_PROFILE_free(struct stack_st_SRTP_PROTECTION_PROFILE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_SRTP_PROTECTION_PROFILE_zero(struct stack_st_SRTP_PROTECTION_PROFILE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_delete(struct stack_st_SRTP_PROTECTION_PROFILE *sk, int i) { return (SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_delete_ptr(struct stack_st_SRTP_PROTECTION_PROFILE *sk, SRTP_PROTECTION_PROFILE *ptr) { return (SRTP_PROTECTION_PROFILE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SRTP_PROTECTION_PROFILE_push(struct stack_st_SRTP_PROTECTION_PROFILE *sk, SRTP_PROTECTION_PROFILE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SRTP_PROTECTION_PROFILE_unshift(struct stack_st_SRTP_PROTECTION_PROFILE *sk, SRTP_PROTECTION_PROFILE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_pop(struct stack_st_SRTP_PROTECTION_PROFILE *sk) { return (SRTP_PROTECTION_PROFILE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_shift(struct stack_st_SRTP_PROTECTION_PROFILE *sk) { return (SRTP_PROTECTION_PROFILE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_SRTP_PROTECTION_PROFILE_pop_free(struct stack_st_SRTP_PROTECTION_PROFILE *sk, sk_SRTP_PROTECTION_PROFILE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_SRTP_PROTECTION_PROFILE_insert(struct stack_st_SRTP_PROTECTION_PROFILE *sk, SRTP_PROTECTION_PROFILE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_set(struct stack_st_SRTP_PROTECTION_PROFILE *sk, int idx, SRTP_PROTECTION_PROFILE *ptr) { return (SRTP_PROTECTION_PROFILE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_SRTP_PROTECTION_PROFILE_find(struct stack_st_SRTP_PROTECTION_PROFILE *sk, SRTP_PROTECTION_PROFILE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SRTP_PROTECTION_PROFILE_find_ex(struct stack_st_SRTP_PROTECTION_PROFILE *sk, SRTP_PROTECTION_PROFILE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_SRTP_PROTECTION_PROFILE_sort(struct stack_st_SRTP_PROTECTION_PROFILE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_SRTP_PROTECTION_PROFILE_is_sorted(const struct stack_st_SRTP_PROTECTION_PROFILE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_SRTP_PROTECTION_PROFILE * sk_SRTP_PROTECTION_PROFILE_dup(const struct stack_st_SRTP_PROTECTION_PROFILE *sk) { return (struct stack_st_SRTP_PROTECTION_PROFILE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_SRTP_PROTECTION_PROFILE *sk_SRTP_PROTECTION_PROFILE_deep_copy(const struct stack_st_SRTP_PROTECTION_PROFILE *sk, sk_SRTP_PROTECTION_PROFILE_copyfunc copyfunc, sk_SRTP_PROTECTION_PROFILE_freefunc freefunc) { return (struct stack_st_SRTP_PROTECTION_PROFILE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_SRTP_PROTECTION_PROFILE_compfunc sk_SRTP_PROTECTION_PROFILE_set_cmp_func(struct stack_st_SRTP_PROTECTION_PROFILE *sk, sk_SRTP_PROTECTION_PROFILE_compfunc compare) { return (sk_SRTP_PROTECTION_PROFILE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef int (*tls_session_ticket_ext_cb_fn) (SSL *s,
> const unsigned char *data,
> int len, void *arg);
>typedef int (*tls_session_secret_cb_fn) (SSL *s, void *secret,
> int *secret_len,
> struct stack_st_SSL_CIPHER *peer_ciphers,
> const SSL_CIPHER **cipher, void *arg);
>
>
>
>typedef int (*custom_ext_add_cb) (SSL *s, unsigned int ext_type,
> const unsigned char **out,
> size_t *outlen, int *al, void *add_arg);
>
>typedef void (*custom_ext_free_cb) (SSL *s, unsigned int ext_type,
> const unsigned char *out, void *add_arg);
>
>typedef int (*custom_ext_parse_cb) (SSL *s, unsigned int ext_type,
> const unsigned char *in,
> size_t inlen, int *al, void *parse_arg);
>
>
>typedef int (*SSL_verify_cb)(int preverify_ok, X509_STORE_CTX *x509_ctx);
># 509 "/usr/include/openssl/ssl.h" 3 4
>unsigned long SSL_CTX_get_options(const SSL_CTX *ctx);
>unsigned long SSL_get_options(const SSL* s);
>unsigned long SSL_CTX_clear_options(SSL_CTX *ctx, unsigned long op);
>unsigned long SSL_clear_options(SSL *s, unsigned long op);
>unsigned long SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op);
>unsigned long SSL_set_options(SSL *s, unsigned long op);
># 552 "/usr/include/openssl/ssl.h" 3 4
>void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
> void (*cb) (int write_p, int version,
> int content_type, const void *buf,
> size_t len, SSL *ssl, void *arg));
>void SSL_set_msg_callback(SSL *ssl,
> void (*cb) (int write_p, int version,
> int content_type, const void *buf,
> size_t len, SSL *ssl, void *arg));
># 569 "/usr/include/openssl/ssl.h" 3 4
> int SSL_SRP_CTX_init(SSL *s);
> int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx);
>int SSL_SRP_CTX_free(SSL *ctx);
>int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx);
> int SSL_srp_server_param_with_username(SSL *s, int *ad);
> int SRP_Calc_A_param(SSL *s);
># 595 "/usr/include/openssl/ssl.h" 3 4
>typedef int (*GEN_SESSION_CB) (const SSL *ssl, unsigned char *id,
> unsigned int *id_len);
># 609 "/usr/include/openssl/ssl.h" 3 4
>struct lhash_st_SSL_SESSION *SSL_CTX_sessions(SSL_CTX *ctx);
># 635 "/usr/include/openssl/ssl.h" 3 4
>void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
> int (*new_session_cb) (struct ssl_st *ssl,
> SSL_SESSION *sess));
>int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
> SSL_SESSION *sess);
>void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
> void (*remove_session_cb) (struct ssl_ctx_st
> *ctx,
> SSL_SESSION
> *sess));
>void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx,
> SSL_SESSION *sess);
>void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
> SSL_SESSION *(*get_session_cb) (struct ssl_st
> *ssl,
> const unsigned char
> *data, int len,
> int *copy));
>SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,
> const unsigned char *data,
> int len, int *copy);
>void SSL_CTX_set_info_callback(SSL_CTX *ctx,
> void (*cb) (const SSL *ssl, int type,
> int val));
>void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,
> int val);
>void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
> int (*client_cert_cb) (SSL *ssl, X509 **x509,
> EVP_PKEY **pkey));
>int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,
> EVP_PKEY **pkey);
>
> int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e);
>
>void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
> int (*app_gen_cookie_cb) (SSL *ssl,
> unsigned char
> *cookie,
> unsigned int
> *cookie_len));
>void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
> int (*app_verify_cookie_cb) (SSL *ssl,
> const unsigned char
> *cookie,
> unsigned int
> cookie_len));
>
>void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s,
> int (*cb) (SSL *ssl,
> const unsigned char
> **out,
> unsigned int *outlen,
> void *arg), void *arg);
>void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s,
> int (*cb) (SSL *ssl,
> unsigned char **out,
> unsigned char *outlen,
> const unsigned char *in,
> unsigned int inlen,
> void *arg), void *arg);
>void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
> unsigned *len);
>
>
> int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
> const unsigned char *in, unsigned int inlen,
> const unsigned char *client,
> unsigned int client_len);
>
>
>
>
>
> int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
> unsigned int protos_len);
> int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
> unsigned int protos_len);
>void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
> int (*cb) (SSL *ssl,
> const unsigned char **out,
> unsigned char *outlen,
> const unsigned char *in,
> unsigned int inlen,
> void *arg), void *arg);
>void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
> unsigned int *len);
># 729 "/usr/include/openssl/ssl.h" 3 4
>void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
> unsigned int (*psk_client_callback) (SSL
> *ssl,
> const
> char
> *hint,
> char
> *identity,
> unsigned
> int
> max_identity_len,
> unsigned
> char
> *psk,
> unsigned
> int
> max_psk_len));
>void SSL_set_psk_client_callback(SSL *ssl,
> unsigned int (*psk_client_callback) (SSL
> *ssl,
> const
> char
> *hint,
> char
> *identity,
> unsigned
> int
> max_identity_len,
> unsigned
> char
> *psk,
> unsigned
> int
> max_psk_len));
>void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
> unsigned int (*psk_server_callback) (SSL
> *ssl,
> const
> char
> *identity,
> unsigned
> char
> *psk,
> unsigned
> int
> max_psk_len));
>void SSL_set_psk_server_callback(SSL *ssl,
> unsigned int (*psk_server_callback) (SSL
> *ssl,
> const
> char
> *identity,
> unsigned
> char
> *psk,
> unsigned
> int
> max_psk_len));
> int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);
> int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);
>const char *SSL_get_psk_identity_hint(const SSL *s);
>const char *SSL_get_psk_identity(const SSL *s);
>
>
>
>
> int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx,
> unsigned int ext_type);
>
> int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
> custom_ext_add_cb add_cb,
> custom_ext_free_cb free_cb,
> void *add_arg,
> custom_ext_parse_cb parse_cb,
> void *parse_arg);
>
> int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
> custom_ext_add_cb add_cb,
> custom_ext_free_cb free_cb,
> void *add_arg,
> custom_ext_parse_cb parse_cb,
> void *parse_arg);
>
> int SSL_extension_supported(unsigned int ext_type);
># 833 "/usr/include/openssl/ssl.h" 3 4
>}
>
>
># 1 "/usr/include/openssl/ssl2.h" 1 3 4
># 14 "/usr/include/openssl/ssl2.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
>}
># 837 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/ssl3.h" 1 3 4
># 22 "/usr/include/openssl/ssl3.h" 3 4
># 1 "/usr/include/openssl/ssl.h" 1 3 4
># 23 "/usr/include/openssl/ssl3.h" 2 3 4
>
>
>extern "C" {
># 308 "/usr/include/openssl/ssl3.h" 3 4
>}
># 838 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/tls1.h" 1 3 4
># 57 "/usr/include/openssl/tls1.h" 3 4
>extern "C" {
># 222 "/usr/include/openssl/tls1.h" 3 4
> const char *SSL_get_servername(const SSL *s, const int type);
> int SSL_get_servername_type(const SSL *s);
>
>
>
>
>
>
>
> int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
> const char *label, size_t llen,
> const unsigned char *context,
> size_t contextlen, int use_context);
>
>int SSL_get_sigalgs(SSL *s, int idx,
> int *psign, int *phash, int *psignandhash,
> unsigned char *rsig, unsigned char *rhash);
>
>int SSL_get_shared_sigalgs(SSL *s, int idx,
> int *psign, int *phash, int *psignandhash,
> unsigned char *rsig, unsigned char *rhash);
>
> int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, struct stack_st_X509 *chain);
># 964 "/usr/include/openssl/tls1.h" 3 4
>struct tls_session_ticket_ext_st {
> unsigned short length;
> void *data;
>};
>
>
>}
># 839 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/dtls1.h" 1 3 4
># 14 "/usr/include/openssl/dtls1.h" 3 4
>extern "C" {
># 54 "/usr/include/openssl/dtls1.h" 3 4
>}
># 840 "/usr/include/openssl/ssl.h" 2 3 4
># 1 "/usr/include/openssl/srtp.h" 1 3 4
># 22 "/usr/include/openssl/srtp.h" 3 4
>extern "C" {
># 38 "/usr/include/openssl/srtp.h" 3 4
> int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles);
> int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles);
>
> struct stack_st_SRTP_PROTECTION_PROFILE *SSL_get_srtp_profiles(SSL *ssl);
> SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s);
>
>
>
>
>}
># 841 "/usr/include/openssl/ssl.h" 2 3 4
>
>
>extern "C" {
>
>
>
>
>
>
>struct stack_st_SSL_CIPHER; typedef int (*sk_SSL_CIPHER_compfunc)(const SSL_CIPHER * const *a, const SSL_CIPHER *const *b); typedef void (*sk_SSL_CIPHER_freefunc)(SSL_CIPHER *a); typedef SSL_CIPHER * (*sk_SSL_CIPHER_copyfunc)(const SSL_CIPHER *a); static inline int sk_SSL_CIPHER_num(const struct stack_st_SSL_CIPHER *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline const SSL_CIPHER *sk_SSL_CIPHER_value(const struct stack_st_SSL_CIPHER *sk, int idx) { return (const SSL_CIPHER *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_SSL_CIPHER *sk_SSL_CIPHER_new(sk_SSL_CIPHER_compfunc compare) { return (struct stack_st_SSL_CIPHER *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_SSL_CIPHER *sk_SSL_CIPHER_new_null(void) { return (struct stack_st_SSL_CIPHER *)OPENSSL_sk_new_null(); } static inline void sk_SSL_CIPHER_free(struct stack_st_SSL_CIPHER *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_SSL_CIPHER_zero(struct stack_st_SSL_CIPHER *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline const SSL_CIPHER *sk_SSL_CIPHER_delete(struct stack_st_SSL_CIPHER *sk, int i) { return (const SSL_CIPHER *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline const SSL_CIPHER *sk_SSL_CIPHER_delete_ptr(struct stack_st_SSL_CIPHER *sk, const SSL_CIPHER *ptr) { return (const SSL_CIPHER *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SSL_CIPHER_push(struct stack_st_SSL_CIPHER *sk, const SSL_CIPHER *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SSL_CIPHER_unshift(struct stack_st_SSL_CIPHER *sk, const SSL_CIPHER *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline const SSL_CIPHER *sk_SSL_CIPHER_pop(struct stack_st_SSL_CIPHER *sk) { return (const SSL_CIPHER *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline const SSL_CIPHER *sk_SSL_CIPHER_shift(struct stack_st_SSL_CIPHER *sk) { return (const SSL_CIPHER *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_SSL_CIPHER_pop_free(struct stack_st_SSL_CIPHER *sk, sk_SSL_CIPHER_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_SSL_CIPHER_insert(struct stack_st_SSL_CIPHER *sk, const SSL_CIPHER *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline const SSL_CIPHER *sk_SSL_CIPHER_set(struct stack_st_SSL_CIPHER *sk, int idx, const SSL_CIPHER *ptr) { return (const SSL_CIPHER *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_SSL_CIPHER_find(struct stack_st_SSL_CIPHER *sk, const SSL_CIPHER *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SSL_CIPHER_find_ex(struct stack_st_SSL_CIPHER *sk, const SSL_CIPHER *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_SSL_CIPHER_sort(struct stack_st_SSL_CIPHER *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_SSL_CIPHER_is_sorted(const struct stack_st_SSL_CIPHER *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_SSL_CIPHER * sk_SSL_CIPHER_dup(const struct stack_st_SSL_CIPHER *sk) { return (struct stack_st_SSL_CIPHER *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_SSL_CIPHER *sk_SSL_CIPHER_deep_copy(const struct stack_st_SSL_CIPHER *sk, sk_SSL_CIPHER_copyfunc copyfunc, sk_SSL_CIPHER_freefunc freefunc) { return (struct stack_st_SSL_CIPHER *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_SSL_CIPHER_compfunc sk_SSL_CIPHER_set_cmp_func(struct stack_st_SSL_CIPHER *sk, sk_SSL_CIPHER_compfunc compare) { return (sk_SSL_CIPHER_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>struct stack_st_SSL_COMP; typedef int (*sk_SSL_COMP_compfunc)(const SSL_COMP * const *a, const SSL_COMP *const *b); typedef void (*sk_SSL_COMP_freefunc)(SSL_COMP *a); typedef SSL_COMP * (*sk_SSL_COMP_copyfunc)(const SSL_COMP *a); static inline int sk_SSL_COMP_num(const struct stack_st_SSL_COMP *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline SSL_COMP *sk_SSL_COMP_value(const struct stack_st_SSL_COMP *sk, int idx) { return (SSL_COMP *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_SSL_COMP *sk_SSL_COMP_new(sk_SSL_COMP_compfunc compare) { return (struct stack_st_SSL_COMP *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_SSL_COMP *sk_SSL_COMP_new_null(void) { return (struct stack_st_SSL_COMP *)OPENSSL_sk_new_null(); } static inline void sk_SSL_COMP_free(struct stack_st_SSL_COMP *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_SSL_COMP_zero(struct stack_st_SSL_COMP *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline SSL_COMP *sk_SSL_COMP_delete(struct stack_st_SSL_COMP *sk, int i) { return (SSL_COMP *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline SSL_COMP *sk_SSL_COMP_delete_ptr(struct stack_st_SSL_COMP *sk, SSL_COMP *ptr) { return (SSL_COMP *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SSL_COMP_push(struct stack_st_SSL_COMP *sk, SSL_COMP *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SSL_COMP_unshift(struct stack_st_SSL_COMP *sk, SSL_COMP *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline SSL_COMP *sk_SSL_COMP_pop(struct stack_st_SSL_COMP *sk) { return (SSL_COMP *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline SSL_COMP *sk_SSL_COMP_shift(struct stack_st_SSL_COMP *sk) { return (SSL_COMP *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_SSL_COMP_pop_free(struct stack_st_SSL_COMP *sk, sk_SSL_COMP_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_SSL_COMP_insert(struct stack_st_SSL_COMP *sk, SSL_COMP *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline SSL_COMP *sk_SSL_COMP_set(struct stack_st_SSL_COMP *sk, int idx, SSL_COMP *ptr) { return (SSL_COMP *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_SSL_COMP_find(struct stack_st_SSL_COMP *sk, SSL_COMP *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SSL_COMP_find_ex(struct stack_st_SSL_COMP *sk, SSL_COMP *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_SSL_COMP_sort(struct stack_st_SSL_COMP *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_SSL_COMP_is_sorted(const struct stack_st_SSL_COMP *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_SSL_COMP * sk_SSL_COMP_dup(const struct stack_st_SSL_COMP *sk) { return (struct stack_st_SSL_COMP *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_SSL_COMP *sk_SSL_COMP_deep_copy(const struct stack_st_SSL_COMP *sk, sk_SSL_COMP_copyfunc copyfunc, sk_SSL_COMP_freefunc freefunc) { return (struct stack_st_SSL_COMP *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_SSL_COMP_compfunc sk_SSL_COMP_set_cmp_func(struct stack_st_SSL_COMP *sk, sk_SSL_COMP_compfunc compare) { return (sk_SSL_COMP_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
># 860 "/usr/include/openssl/ssl.h" 3 4
>void SSL_set_debug(SSL *s, int debug) __attribute__ ((deprecated));
># 875 "/usr/include/openssl/ssl.h" 3 4
>typedef enum {
> TLS_ST_BEFORE,
> TLS_ST_OK,
> DTLS_ST_CR_HELLO_VERIFY_REQUEST,
> TLS_ST_CR_SRVR_HELLO,
> TLS_ST_CR_CERT,
> TLS_ST_CR_CERT_STATUS,
> TLS_ST_CR_KEY_EXCH,
> TLS_ST_CR_CERT_REQ,
> TLS_ST_CR_SRVR_DONE,
> TLS_ST_CR_SESSION_TICKET,
> TLS_ST_CR_CHANGE,
> TLS_ST_CR_FINISHED,
> TLS_ST_CW_CLNT_HELLO,
> TLS_ST_CW_CERT,
> TLS_ST_CW_KEY_EXCH,
> TLS_ST_CW_CERT_VRFY,
> TLS_ST_CW_CHANGE,
> TLS_ST_CW_NEXT_PROTO,
> TLS_ST_CW_FINISHED,
> TLS_ST_SW_HELLO_REQ,
> TLS_ST_SR_CLNT_HELLO,
> DTLS_ST_SW_HELLO_VERIFY_REQUEST,
> TLS_ST_SW_SRVR_HELLO,
> TLS_ST_SW_CERT,
> TLS_ST_SW_KEY_EXCH,
> TLS_ST_SW_CERT_REQ,
> TLS_ST_SW_SRVR_DONE,
> TLS_ST_SR_CERT,
> TLS_ST_SR_KEY_EXCH,
> TLS_ST_SR_CERT_VRFY,
> TLS_ST_SR_NEXT_PROTO,
> TLS_ST_SR_CHANGE,
> TLS_ST_SR_FINISHED,
> TLS_ST_SW_SESSION_TICKET,
> TLS_ST_SW_CERT_STATUS,
> TLS_ST_SW_CHANGE,
> TLS_ST_SW_FINISHED
>} OSSL_HANDSHAKE_STATE;
># 945 "/usr/include/openssl/ssl.h" 3 4
>int SSL_in_init(SSL *s);
>int SSL_in_before(SSL *s);
>int SSL_is_init_finished(SSL *s);
># 963 "/usr/include/openssl/ssl.h" 3 4
>size_t SSL_get_finished(const SSL *s, void *buf, size_t count);
>size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count);
># 997 "/usr/include/openssl/ssl.h" 3 4
>SSL_SESSION *PEM_read_bio_SSL_SESSION(BIO *bp, SSL_SESSION **x, pem_password_cb *cb, void *u); SSL_SESSION *PEM_read_SSL_SESSION(FILE *fp, SSL_SESSION **x, pem_password_cb *cb, void *u); int PEM_write_bio_SSL_SESSION(BIO *bp, SSL_SESSION *x); int PEM_write_SSL_SESSION(FILE *fp, SSL_SESSION *x);
># 1333 "/usr/include/openssl/ssl.h" 3 4
> const BIO_METHOD *BIO_f_ssl(void);
> BIO *BIO_new_ssl(SSL_CTX *ctx, int client);
> BIO *BIO_new_ssl_connect(SSL_CTX *ctx);
> BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx);
> int BIO_ssl_copy_session_id(BIO *to, BIO *from);
>void BIO_ssl_shutdown(BIO *ssl_bio);
>
> int SSL_CTX_set_cipher_list(SSL_CTX *, const char *str);
> SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth);
>int SSL_CTX_up_ref(SSL_CTX *ctx);
>void SSL_CTX_free(SSL_CTX *);
> long SSL_CTX_set_timeout(SSL_CTX *ctx, long t);
> long SSL_CTX_get_timeout(const SSL_CTX *ctx);
> X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *);
>void SSL_CTX_set_cert_store(SSL_CTX *, X509_STORE *);
> int SSL_want(const SSL *s);
> int SSL_clear(SSL *s);
>
>void SSL_CTX_flush_sessions(SSL_CTX *ctx, long tm);
>
> const SSL_CIPHER *SSL_get_current_cipher(const SSL *s);
> int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits);
> const char *SSL_CIPHER_get_version(const SSL_CIPHER *c);
> const char *SSL_CIPHER_get_name(const SSL_CIPHER *c);
> uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c);
> int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c);
> int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c);
> int SSL_CIPHER_is_aead(const SSL_CIPHER *c);
>
> int SSL_get_fd(const SSL *s);
> int SSL_get_rfd(const SSL *s);
> int SSL_get_wfd(const SSL *s);
> const char *SSL_get_cipher_list(const SSL *s, int n);
> char *SSL_get_shared_ciphers(const SSL *s, char *buf, int len);
> int SSL_get_read_ahead(const SSL *s);
> int SSL_pending(const SSL *s);
> int SSL_has_pending(const SSL *s);
>
> int SSL_set_fd(SSL *s, int fd);
> int SSL_set_rfd(SSL *s, int fd);
> int SSL_set_wfd(SSL *s, int fd);
>
>void SSL_set0_rbio(SSL *s, BIO *rbio);
>void SSL_set0_wbio(SSL *s, BIO *wbio);
>void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio);
> BIO *SSL_get_rbio(const SSL *s);
> BIO *SSL_get_wbio(const SSL *s);
> int SSL_set_cipher_list(SSL *s, const char *str);
>void SSL_set_read_ahead(SSL *s, int yes);
> int SSL_get_verify_mode(const SSL *s);
> int SSL_get_verify_depth(const SSL *s);
> SSL_verify_cb SSL_get_verify_callback(const SSL *s);
>void SSL_set_verify(SSL *s, int mode, SSL_verify_cb callback);
>void SSL_set_verify_depth(SSL *s, int depth);
>void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg);
>
> int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
> int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, const unsigned char *d, long len);
>
> int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
> int SSL_use_PrivateKey_ASN1(int pk, SSL *ssl, const unsigned char *d,
> long len);
> int SSL_use_certificate(SSL *ssl, X509 *x);
> int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len);
>
>
> int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
> size_t serverinfo_length);
> int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file);
>
>
> int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type);
>
>
> int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type);
> int SSL_use_certificate_file(SSL *ssl, const char *file, int type);
>
>
> int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type);
>
> int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type);
> int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type);
>
> int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file);
> int SSL_use_certificate_chain_file(SSL *ssl, const char *file);
> struct stack_st_X509_NAME *SSL_load_client_CA_file(const char *file);
> int SSL_add_file_cert_subjects_to_stack(struct stack_st_X509_NAME *stackCAs,
> const char *file);
>int SSL_add_dir_cert_subjects_to_stack(struct stack_st_X509_NAME *stackCAs,
> const char *dir);
>
>
>
>
>
>
>
> const char *SSL_state_string(const SSL *s);
> const char *SSL_rstate_string(const SSL *s);
> const char *SSL_state_string_long(const SSL *s);
> const char *SSL_rstate_string_long(const SSL *s);
> long SSL_SESSION_get_time(const SSL_SESSION *s);
> long SSL_SESSION_set_time(SSL_SESSION *s, long t);
> long SSL_SESSION_get_timeout(const SSL_SESSION *s);
> long SSL_SESSION_set_timeout(SSL_SESSION *s, long t);
> int SSL_SESSION_get_protocol_version(const SSL_SESSION *s);
> const char *SSL_SESSION_get0_hostname(const SSL_SESSION *s);
> const SSL_CIPHER *SSL_SESSION_get0_cipher(const SSL_SESSION *s);
> int SSL_SESSION_has_ticket(const SSL_SESSION *s);
> unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s);
>void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick,
> size_t *len);
> int SSL_copy_session_id(SSL *to, const SSL *from);
> X509 *SSL_SESSION_get0_peer(SSL_SESSION *s);
> int SSL_SESSION_set1_id_context(SSL_SESSION *s, const unsigned char *sid_ctx,
> unsigned int sid_ctx_len);
> int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid,
> unsigned int sid_len);
>
> SSL_SESSION *SSL_SESSION_new(void);
>const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s,
> unsigned int *len);
>const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s,
> unsigned int *len);
> unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s);
>
>int SSL_SESSION_print_fp(FILE *fp, const SSL_SESSION *ses);
>
>int SSL_SESSION_print(BIO *fp, const SSL_SESSION *ses);
>int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x);
>int SSL_SESSION_up_ref(SSL_SESSION *ses);
>void SSL_SESSION_free(SSL_SESSION *ses);
> int i2d_SSL_SESSION(SSL_SESSION *in, unsigned char **pp);
> int SSL_set_session(SSL *to, SSL_SESSION *session);
>int SSL_CTX_add_session(SSL_CTX *s, SSL_SESSION *c);
>int SSL_CTX_remove_session(SSL_CTX *, SSL_SESSION *c);
> int SSL_CTX_set_generate_session_id(SSL_CTX *, GEN_SESSION_CB);
> int SSL_set_generate_session_id(SSL *, GEN_SESSION_CB);
> int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
> unsigned int id_len);
>SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
> long length);
>
>
> X509 *SSL_get_peer_certificate(const SSL *s);
>
>
> struct stack_st_X509 *SSL_get_peer_cert_chain(const SSL *s);
>
> int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);
> int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);
> SSL_verify_cb SSL_CTX_get_verify_callback(const SSL_CTX *ctx);
>void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, SSL_verify_cb callback);
>void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth);
>void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
> int (*cb) (X509_STORE_CTX *, void *),
> void *arg);
>void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
> void *arg);
>
> int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
> int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
> long len);
>
> int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
> int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx,
> const unsigned char *d, long len);
> int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x);
> int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len,
> const unsigned char *d);
>
>void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb);
>void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u);
>pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx);
>void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx);
>void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb);
>void SSL_set_default_passwd_cb_userdata(SSL *s, void *u);
>pem_password_cb *SSL_get_default_passwd_cb(SSL *s);
>void *SSL_get_default_passwd_cb_userdata(SSL *s);
>
> int SSL_CTX_check_private_key(const SSL_CTX *ctx);
> int SSL_check_private_key(const SSL *ctx);
>
> int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
> unsigned int sid_ctx_len);
>
>SSL *SSL_new(SSL_CTX *ctx);
>int SSL_up_ref(SSL *s);
>int SSL_is_dtls(const SSL *s);
> int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
> unsigned int sid_ctx_len);
>
> int SSL_CTX_set_purpose(SSL_CTX *s, int purpose);
> int SSL_set_purpose(SSL *s, int purpose);
> int SSL_CTX_set_trust(SSL_CTX *s, int trust);
> int SSL_set_trust(SSL *s, int trust);
>
> int SSL_set1_host(SSL *s, const char *hostname);
> int SSL_add1_host(SSL *s, const char *hostname);
> const char *SSL_get0_peername(SSL *s);
>void SSL_set_hostflags(SSL *s, unsigned int flags);
>
> int SSL_CTX_dane_enable(SSL_CTX *ctx);
> int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md,
> uint8_t mtype, uint8_t ord);
> int SSL_dane_enable(SSL *s, const char *basedomain);
> int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
> uint8_t mtype, unsigned const char *data, size_t dlen);
> int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki);
> int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
> uint8_t *mtype, unsigned const char **data,
> size_t *dlen);
>
>
>
>
>SSL_DANE *SSL_get0_dane(SSL *ssl);
>
>
>
>unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags);
>unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags);
>unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags);
>unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags);
>
> int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm);
> int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm);
>
> X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx);
> X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl);
>
>
>int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name);
>int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password);
>int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength);
>int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
> char *(*cb) (SSL *, void *));
>int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
> int (*cb) (SSL *, void *));
>int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
> int (*cb) (SSL *, int *, void *));
>int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg);
>
>int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
> BIGNUM *sa, BIGNUM *v, char *info);
>int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
> const char *grp);
>
> BIGNUM *SSL_get_srp_g(SSL *s);
> BIGNUM *SSL_get_srp_N(SSL *s);
>
> char *SSL_get_srp_username(SSL *s);
> char *SSL_get_srp_userinfo(SSL *s);
>
>
>void SSL_certs_clear(SSL *s);
>void SSL_free(SSL *ssl);
>
>
>
>
> int SSL_waiting_for_async(SSL *s);
> int SSL_get_all_async_fds(SSL *s, int *fds, size_t *numfds);
> int SSL_get_changed_async_fds(SSL *s, int *addfd,
> size_t *numaddfds, int *delfd,
> size_t *numdelfds);
>
> int SSL_accept(SSL *ssl);
> int SSL_connect(SSL *ssl);
> int SSL_read(SSL *ssl, void *buf, int num);
> int SSL_peek(SSL *ssl, void *buf, int num);
> int SSL_write(SSL *ssl, const void *buf, int num);
>long SSL_ctrl(SSL *ssl, int cmd, long larg, void *parg);
>long SSL_callback_ctrl(SSL *, int, void (*)(void));
>long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);
>long SSL_CTX_callback_ctrl(SSL_CTX *, int, void (*)(void));
>
> int SSL_get_error(const SSL *s, int ret_code);
> const char *SSL_get_version(const SSL *s);
>
>
> int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth);
>
>
>const SSL_METHOD *SSLv3_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *SSLv3_server_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *SSLv3_client_method(void) __attribute__ ((deprecated));
>
>
>
>
>
>
>
> const SSL_METHOD *TLS_method(void);
> const SSL_METHOD *TLS_server_method(void);
> const SSL_METHOD *TLS_client_method(void);
>
>
>const SSL_METHOD *TLSv1_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *TLSv1_server_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *TLSv1_client_method(void) __attribute__ ((deprecated));
>
>
>
>const SSL_METHOD *TLSv1_1_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *TLSv1_1_server_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *TLSv1_1_client_method(void) __attribute__ ((deprecated));
>
>
>
>const SSL_METHOD *TLSv1_2_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *TLSv1_2_server_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *TLSv1_2_client_method(void) __attribute__ ((deprecated));
>
>
>
>const SSL_METHOD *DTLSv1_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *DTLSv1_server_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *DTLSv1_client_method(void) __attribute__ ((deprecated));
>
>
>
>const SSL_METHOD *DTLSv1_2_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *DTLSv1_2_server_method(void) __attribute__ ((deprecated));
>const SSL_METHOD *DTLSv1_2_client_method(void) __attribute__ ((deprecated));
>
>
> const SSL_METHOD *DTLS_method(void);
> const SSL_METHOD *DTLS_server_method(void);
> const SSL_METHOD *DTLS_client_method(void);
>
> struct stack_st_SSL_CIPHER *SSL_get_ciphers(const SSL *s);
> struct stack_st_SSL_CIPHER *SSL_CTX_get_ciphers(const SSL_CTX *ctx);
> struct stack_st_SSL_CIPHER *SSL_get_client_ciphers(const SSL *s);
> struct stack_st_SSL_CIPHER *SSL_get1_supported_ciphers(SSL *s);
>
> int SSL_do_handshake(SSL *s);
>int SSL_renegotiate(SSL *s);
> int SSL_renegotiate_abbreviated(SSL *s);
> int SSL_renegotiate_pending(SSL *s);
>int SSL_shutdown(SSL *s);
>
> const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx);
> const SSL_METHOD *SSL_get_ssl_method(SSL *s);
> int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method);
> const char *SSL_alert_type_string_long(int value);
> const char *SSL_alert_type_string(int value);
> const char *SSL_alert_desc_string_long(int value);
> const char *SSL_alert_desc_string(int value);
>
>void SSL_set_client_CA_list(SSL *s, struct stack_st_X509_NAME *name_list);
>void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, struct stack_st_X509_NAME *name_list);
> struct stack_st_X509_NAME *SSL_get_client_CA_list(const SSL *s);
> struct stack_st_X509_NAME *SSL_CTX_get_client_CA_list(const SSL_CTX *s);
> int SSL_add_client_CA(SSL *ssl, X509 *x);
> int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x);
>
>void SSL_set_connect_state(SSL *s);
>void SSL_set_accept_state(SSL *s);
>
> long SSL_get_default_timeout(const SSL *s);
>
>
>
>
>
> char *SSL_CIPHER_description(const SSL_CIPHER *, char *buf, int size);
> struct stack_st_X509_NAME *SSL_dup_CA_list(struct stack_st_X509_NAME *sk);
>
> SSL *SSL_dup(SSL *ssl);
>
> X509 *SSL_get_certificate(const SSL *ssl);
>
>
> struct evp_pkey_st *SSL_get_privatekey(const SSL *ssl);
>
> X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx);
> EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx);
>
>void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode);
> int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx);
>void SSL_set_quiet_shutdown(SSL *ssl, int mode);
> int SSL_get_quiet_shutdown(const SSL *ssl);
>void SSL_set_shutdown(SSL *ssl, int mode);
> int SSL_get_shutdown(const SSL *ssl);
> int SSL_version(const SSL *ssl);
> int SSL_client_version(const SSL *s);
> int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
> int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx);
> int SSL_CTX_set_default_verify_file(SSL_CTX *ctx);
> int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
> const char *CApath);
>
> SSL_SESSION *SSL_get_session(const SSL *ssl);
> SSL_SESSION *SSL_get1_session(SSL *ssl);
> SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl);
>SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx);
>void SSL_set_info_callback(SSL *ssl,
> void (*cb) (const SSL *ssl, int type, int val));
>void (*SSL_get_info_callback(const SSL *ssl)) (const SSL *ssl, int type,
> int val);
> OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl);
>
>void SSL_set_verify_result(SSL *ssl, long v);
> long SSL_get_verify_result(const SSL *ssl);
> struct stack_st_X509 *SSL_get0_verified_chain(const SSL *s);
>
> size_t SSL_get_client_random(const SSL *ssl, unsigned char *out,
> size_t outlen);
> size_t SSL_get_server_random(const SSL *ssl, unsigned char *out,
> size_t outlen);
> size_t SSL_SESSION_get_master_key(const SSL_SESSION *ssl,
> unsigned char *out, size_t outlen);
>
>
>
> int SSL_set_ex_data(SSL *ssl, int idx, void *data);
>void *SSL_get_ex_data(const SSL *ssl, int idx);
>
>
> int SSL_SESSION_set_ex_data(SSL_SESSION *ss, int idx, void *data);
>void *SSL_SESSION_get_ex_data(const SSL_SESSION *ss, int idx);
>
>
> int SSL_CTX_set_ex_data(SSL_CTX *ssl, int idx, void *data);
>void *SSL_CTX_get_ex_data(const SSL_CTX *ssl, int idx);
>
> int SSL_get_ex_data_X509_STORE_CTX_idx(void);
># 1800 "/usr/include/openssl/ssl.h" 3 4
>void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len);
>void SSL_set_default_read_buffer_len(SSL *s, size_t len);
>
>
>
>void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
> DH *(*dh) (SSL *ssl, int is_export,
> int keylength));
>void SSL_set_tmp_dh_callback(SSL *ssl,
> DH *(*dh) (SSL *ssl, int is_export,
> int keylength));
>
>
> const COMP_METHOD *SSL_get_current_compression(SSL *s);
> const COMP_METHOD *SSL_get_current_expansion(SSL *s);
> const char *SSL_COMP_get_name(const COMP_METHOD *comp);
> const char *SSL_COMP_get0_name(const SSL_COMP *comp);
> int SSL_COMP_get_id(const SSL_COMP *comp);
>struct stack_st_SSL_COMP *SSL_COMP_get_compression_methods(void);
> struct stack_st_SSL_COMP *SSL_COMP_set0_compression_methods(struct stack_st_SSL_COMP
> *meths);
>
>
>
> int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm);
>
>const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr);
>int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c);
>int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c);
>
>
> int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len);
>
> int SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb,
> void *arg);
>
>
> int SSL_set_session_secret_cb(SSL *s,
> tls_session_secret_cb_fn tls_session_secret_cb,
> void *arg);
>
>void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
> int (*cb) (SSL *ssl,
> int
> is_forward_secure));
>
>void SSL_set_not_resumable_session_callback(SSL *ssl,
> int (*cb) (SSL *ssl,
> int
> is_forward_secure));
>
>
>
>
> int SSL_session_reused(SSL *s);
> int SSL_is_server(const SSL *s);
>
> SSL_CONF_CTX *SSL_CONF_CTX_new(void);
>int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx);
>void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx);
>unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags);
> unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx, unsigned int flags);
> int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre);
>
>void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl);
>void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx);
>
> int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value);
> int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv);
> int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd);
>
>void SSL_add_ssl_module(void);
>int SSL_config(SSL *s, const char *name);
>int SSL_CTX_config(SSL_CTX *ctx, const char *name);
># 1882 "/usr/include/openssl/ssl.h" 3 4
>int DTLSv1_listen(SSL *s, BIO_ADDR *client);
># 1893 "/usr/include/openssl/ssl.h" 3 4
>typedef int(*ssl_ct_validation_cb)(const CT_POLICY_EVAL_CTX *ctx,
> const struct stack_st_SCT *scts, void *arg);
># 1908 "/usr/include/openssl/ssl.h" 3 4
>int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
> void *arg);
>int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
> ssl_ct_validation_cb callback,
> void *arg);
># 1923 "/usr/include/openssl/ssl.h" 3 4
>enum {
> SSL_CT_VALIDATION_PERMISSIVE = 0,
> SSL_CT_VALIDATION_STRICT
>};
># 1936 "/usr/include/openssl/ssl.h" 3 4
>int SSL_enable_ct(SSL *s, int validation_mode);
>int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode);
>
>
>
>
>int SSL_ct_is_enabled(const SSL *s);
>int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx);
>
>
>const struct stack_st_SCT *SSL_get0_peer_scts(SSL *s);
># 1955 "/usr/include/openssl/ssl.h" 3 4
>int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx);
># 1964 "/usr/include/openssl/ssl.h" 3 4
>int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path);
>
>
>
>
>
>void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs);
># 1979 "/usr/include/openssl/ssl.h" 3 4
>const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx);
># 2041 "/usr/include/openssl/ssl.h" 3 4
>void SSL_set_security_level(SSL *s, int level);
> int SSL_get_security_level(const SSL *s);
>void SSL_set_security_callback(SSL *s,
> int (*cb) (const SSL *s, const SSL_CTX *ctx, int op,
> int bits, int nid, void *other,
> void *ex));
>int (*SSL_get_security_callback(const SSL *s)) (const SSL *s, const SSL_CTX *ctx, int op,
> int bits, int nid,
> void *other, void *ex);
>void SSL_set0_security_ex_data(SSL *s, void *ex);
> void *SSL_get0_security_ex_data(const SSL *s);
>
>void SSL_CTX_set_security_level(SSL_CTX *ctx, int level);
> int SSL_CTX_get_security_level(const SSL_CTX *ctx);
>void SSL_CTX_set_security_callback(SSL_CTX *ctx,
> int (*cb) (const SSL *s, const SSL_CTX *ctx, int op,
> int bits, int nid, void *other,
> void *ex));
>int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
> const SSL_CTX *ctx,
> int op, int bits,
> int nid,
> void *other,
> void *ex);
>void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex);
> void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx);
># 2075 "/usr/include/openssl/ssl.h" 3 4
>int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
>
>
>
>
>
>extern const char SSL_version_str[];
>
>
>
>
>
>
>
>int ERR_load_SSL_strings(void);
># 2570 "/usr/include/openssl/ssl.h" 3 4
>}
># 22 "/usr/include/boost/asio/ssl/detail/openssl_types.hpp" 2 3 4
>
># 1 "/usr/include/openssl/engine.h" 1 3 4
># 19 "/usr/include/openssl/engine.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 20 "/usr/include/openssl/engine.h" 2 3 4
># 28 "/usr/include/openssl/engine.h" 3 4
># 1 "/usr/include/openssl/rand.h" 1 3 4
># 13 "/usr/include/openssl/rand.h" 3 4
># 1 "/usr/include/c++/8/stdlib.h" 1 3 4
># 14 "/usr/include/openssl/rand.h" 2 3 4
>
>
>
>
>extern "C" {
>
>
>
>
>
>struct rand_meth_st {
> int (*seed) (const void *buf, int num);
> int (*bytes) (unsigned char *buf, int num);
> void (*cleanup) (void);
> int (*add) (const void *buf, int num, double entropy);
> int (*pseudorand) (unsigned char *buf, int num);
> int (*status) (void);
>};
>
>
>
>
>
>int RAND_set_rand_method(const RAND_METHOD *meth);
>const RAND_METHOD *RAND_get_rand_method(void);
>
>int RAND_set_rand_engine(ENGINE *engine);
>
>RAND_METHOD *RAND_OpenSSL(void);
>
>
>
>int RAND_bytes(unsigned char *buf, int num);
>int RAND_pseudo_bytes(unsigned char *buf, int num) __attribute__ ((deprecated));
>void RAND_seed(const void *buf, int num);
>
>
>
>void RAND_add(const void *buf, int num, double entropy);
>int RAND_load_file(const char *file, long max_bytes);
>int RAND_write_file(const char *file);
>const char *RAND_file_name(char *file, size_t num);
>int RAND_status(void);
>
>
>
>
>
>int RAND_poll(void);
># 71 "/usr/include/openssl/rand.h" 3 4
>void RAND_set_fips_drbg_type(int type, int flags);
>int RAND_init_fips(void);
># 81 "/usr/include/openssl/rand.h" 3 4
>int ERR_load_RAND_strings(void);
># 95 "/usr/include/openssl/rand.h" 3 4
>}
># 29 "/usr/include/openssl/engine.h" 2 3 4
># 1 "/usr/include/openssl/ui.h" 1 3 4
># 13 "/usr/include/openssl/ui.h" 3 4
># 1 "/usr/include/openssl/opensslconf.h" 1 3 4
># 42 "/usr/include/openssl/opensslconf.h" 3 4
># 1 "/usr/include/openssl/opensslconf-x86_64.h" 1 3 4
># 21 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>extern "C" {
># 162 "/usr/include/openssl/opensslconf-x86_64.h" 3 4
>}
># 43 "/usr/include/openssl/opensslconf.h" 2 3 4
># 14 "/usr/include/openssl/ui.h" 2 3 4
># 24 "/usr/include/openssl/ui.h" 3 4
>extern "C" {
># 35 "/usr/include/openssl/ui.h" 3 4
>UI *UI_new(void);
>UI *UI_new_method(const UI_METHOD *method);
>void UI_free(UI *ui);
># 82 "/usr/include/openssl/ui.h" 3 4
>int UI_add_input_string(UI *ui, const char *prompt, int flags,
> char *result_buf, int minsize, int maxsize);
>int UI_dup_input_string(UI *ui, const char *prompt, int flags,
> char *result_buf, int minsize, int maxsize);
>int UI_add_verify_string(UI *ui, const char *prompt, int flags,
> char *result_buf, int minsize, int maxsize,
> const char *test_buf);
>int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
> char *result_buf, int minsize, int maxsize,
> const char *test_buf);
>int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
> const char *ok_chars, const char *cancel_chars,
> int flags, char *result_buf);
>int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
> const char *ok_chars, const char *cancel_chars,
> int flags, char *result_buf);
>int UI_add_info_string(UI *ui, const char *text);
>int UI_dup_info_string(UI *ui, const char *text);
>int UI_add_error_string(UI *ui, const char *text);
>int UI_dup_error_string(UI *ui, const char *text);
># 145 "/usr/include/openssl/ui.h" 3 4
>char *UI_construct_prompt(UI *ui_method,
> const char *object_desc, const char *object_name);
># 159 "/usr/include/openssl/ui.h" 3 4
>void *UI_add_user_data(UI *ui, void *user_data);
>
>void *UI_get0_user_data(UI *ui);
>
>
>const char *UI_get0_result(UI *ui, int i);
>
>
>int UI_process(UI *ui);
>
>
>
>
>
>
>int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void));
># 196 "/usr/include/openssl/ui.h" 3 4
>int UI_set_ex_data(UI *r, int idx, void *arg);
>void *UI_get_ex_data(UI *r, int idx);
>
>
>void UI_set_default_method(const UI_METHOD *meth);
>const UI_METHOD *UI_get_default_method(void);
>const UI_METHOD *UI_get_method(UI *ui);
>const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth);
>
>
>UI_METHOD *UI_OpenSSL(void);
># 255 "/usr/include/openssl/ui.h" 3 4
>typedef struct ui_string_st UI_STRING;
>struct stack_st_UI_STRING; typedef int (*sk_UI_STRING_compfunc)(const UI_STRING * const *a, const UI_STRING *const *b); typedef void (*sk_UI_STRING_freefunc)(UI_STRING *a); typedef UI_STRING * (*sk_UI_STRING_copyfunc)(const UI_STRING *a); static inline int sk_UI_STRING_num(const struct stack_st_UI_STRING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline UI_STRING *sk_UI_STRING_value(const struct stack_st_UI_STRING *sk, int idx) { return (UI_STRING *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_UI_STRING *sk_UI_STRING_new(sk_UI_STRING_compfunc compare) { return (struct stack_st_UI_STRING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_UI_STRING *sk_UI_STRING_new_null(void) { return (struct stack_st_UI_STRING *)OPENSSL_sk_new_null(); } static inline void sk_UI_STRING_free(struct stack_st_UI_STRING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_UI_STRING_zero(struct stack_st_UI_STRING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline UI_STRING *sk_UI_STRING_delete(struct stack_st_UI_STRING *sk, int i) { return (UI_STRING *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline UI_STRING *sk_UI_STRING_delete_ptr(struct stack_st_UI_STRING *sk, UI_STRING *ptr) { return (UI_STRING *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_UI_STRING_push(struct stack_st_UI_STRING *sk, UI_STRING *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_UI_STRING_unshift(struct stack_st_UI_STRING *sk, UI_STRING *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline UI_STRING *sk_UI_STRING_pop(struct stack_st_UI_STRING *sk) { return (UI_STRING *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline UI_STRING *sk_UI_STRING_shift(struct stack_st_UI_STRING *sk) { return (UI_STRING *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_UI_STRING_pop_free(struct stack_st_UI_STRING *sk, sk_UI_STRING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_UI_STRING_insert(struct stack_st_UI_STRING *sk, UI_STRING *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline UI_STRING *sk_UI_STRING_set(struct stack_st_UI_STRING *sk, int idx, UI_STRING *ptr) { return (UI_STRING *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_UI_STRING_find(struct stack_st_UI_STRING *sk, UI_STRING *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_UI_STRING_find_ex(struct stack_st_UI_STRING *sk, UI_STRING *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_UI_STRING_sort(struct stack_st_UI_STRING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_UI_STRING_is_sorted(const struct stack_st_UI_STRING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_UI_STRING * sk_UI_STRING_dup(const struct stack_st_UI_STRING *sk) { return (struct stack_st_UI_STRING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_UI_STRING *sk_UI_STRING_deep_copy(const struct stack_st_UI_STRING *sk, sk_UI_STRING_copyfunc copyfunc, sk_UI_STRING_freefunc freefunc) { return (struct stack_st_UI_STRING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_UI_STRING_compfunc sk_UI_STRING_set_cmp_func(struct stack_st_UI_STRING *sk, sk_UI_STRING_compfunc compare) { return (sk_UI_STRING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>
>
>enum UI_string_types {
> UIT_NONE = 0,
> UIT_PROMPT,
> UIT_VERIFY,
> UIT_BOOLEAN,
> UIT_INFO,
> UIT_ERROR
>};
>
>
>UI_METHOD *UI_create_method(const char *name);
>void UI_destroy_method(UI_METHOD *ui_method);
>int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui));
>int UI_method_set_writer(UI_METHOD *method,
> int (*writer) (UI *ui, UI_STRING *uis));
>int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui));
>int UI_method_set_reader(UI_METHOD *method,
> int (*reader) (UI *ui, UI_STRING *uis));
>int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui));
>int UI_method_set_prompt_constructor(UI_METHOD *method,
> char *(*prompt_constructor) (UI *ui,
> const char
> *object_desc,
> const char
> *object_name));
>int (*UI_method_get_opener(UI_METHOD *method)) (UI *);
>int (*UI_method_get_writer(UI_METHOD *method)) (UI *, UI_STRING *);
>int (*UI_method_get_flusher(UI_METHOD *method)) (UI *);
>int (*UI_method_get_reader(UI_METHOD *method)) (UI *, UI_STRING *);
>int (*UI_method_get_closer(UI_METHOD *method)) (UI *);
>char *(*UI_method_get_prompt_constructor(UI_METHOD *method)) (UI *,
> const char *,
> const char *);
>
>
>
>
>
>
>
>enum UI_string_types UI_get_string_type(UI_STRING *uis);
>
>int UI_get_input_flags(UI_STRING *uis);
>
>const char *UI_get0_output_string(UI_STRING *uis);
>
>
>
>
>const char *UI_get0_action_string(UI_STRING *uis);
>
>const char *UI_get0_result_string(UI_STRING *uis);
>
>
>
>const char *UI_get0_test_string(UI_STRING *uis);
>
>int UI_get_result_minsize(UI_STRING *uis);
>
>int UI_get_result_maxsize(UI_STRING *uis);
>
>int UI_set_result(UI *ui, UI_STRING *uis, const char *result);
>
>
>int UI_UTIL_read_pw_string(char *buf, int length, const char *prompt,
> int verify);
>int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt,
> int verify);
>
>
>
>
>
>
>
>int ERR_load_UI_strings(void);
># 375 "/usr/include/openssl/ui.h" 3 4
>}
># 30 "/usr/include/openssl/engine.h" 2 3 4
># 1 "/usr/include/openssl/err.h" 1 3 4
># 17 "/usr/include/openssl/err.h" 3 4
># 1 "/usr/include/c++/8/stdlib.h" 1 3 4
># 18 "/usr/include/openssl/err.h" 2 3 4
>
>
>
>
>
>
>
>extern "C" {
># 42 "/usr/include/openssl/err.h" 3 4
>typedef struct err_state_st {
> int err_flags[16];
> unsigned long err_buffer[16];
> char *err_data[16];
> int err_data_flags[16];
> const char *err_file[16];
> int err_line[16];
> int top, bottom;
>} ERR_STATE;
># 201 "/usr/include/openssl/err.h" 3 4
>typedef struct ERR_string_data_st {
> unsigned long error;
> const char *string;
>} ERR_STRING_DATA;
>
>struct lhash_st_ERR_STRING_DATA { union lh_ERR_STRING_DATA_dummy { void* d1; unsigned long d2; int d3; } dummy; }; static inline struct lhash_st_ERR_STRING_DATA * lh_ERR_STRING_DATA_new(unsigned long (*hfn)(const ERR_STRING_DATA *), int (*cfn)(const ERR_STRING_DATA *, const ERR_STRING_DATA *)) { return (struct lhash_st_ERR_STRING_DATA *) OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); } static inline void lh_ERR_STRING_DATA_free(struct lhash_st_ERR_STRING_DATA *lh) { OPENSSL_LH_free((OPENSSL_LHASH *)lh); } static inline ERR_STRING_DATA *lh_ERR_STRING_DATA_insert(struct lhash_st_ERR_STRING_DATA *lh, ERR_STRING_DATA *d) { return (ERR_STRING_DATA *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); } static inline ERR_STRING_DATA *lh_ERR_STRING_DATA_delete(struct lhash_st_ERR_STRING_DATA *lh, const ERR_STRING_DATA *d) { return (ERR_STRING_DATA *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); } static inline ERR_STRING_DATA *lh_ERR_STRING_DATA_retrieve(struct lhash_st_ERR_STRING_DATA *lh, const ERR_STRING_DATA *d) { return (ERR_STRING_DATA *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); } static inline int lh_ERR_STRING_DATA_error(struct lhash_st_ERR_STRING_DATA *lh) { return OPENSSL_LH_error((OPENSSL_LHASH *)lh); } static inline unsigned long lh_ERR_STRING_DATA_num_items(struct lhash_st_ERR_STRING_DATA *lh) { return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); } static inline void lh_ERR_STRING_DATA_node_stats_bio(const struct lhash_st_ERR_STRING_DATA *lh, BIO *out) { OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_ERR_STRING_DATA_node_usage_stats_bio(const struct lhash_st_ERR_STRING_DATA *lh, BIO *out) { OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline void lh_ERR_STRING_DATA_stats_bio(const struct lhash_st_ERR_STRING_DATA *lh, BIO *out) { OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); } static inline unsigned long lh_ERR_STRING_DATA_get_down_load(struct lhash_st_ERR_STRING_DATA *lh) { return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); } static inline void lh_ERR_STRING_DATA_set_down_load(struct lhash_st_ERR_STRING_DATA *lh, unsigned long dl) { OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); } static inline void lh_ERR_STRING_DATA_doall(struct lhash_st_ERR_STRING_DATA *lh, void (*doall)(ERR_STRING_DATA *)) { OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); } struct lhash_st_ERR_STRING_DATA;
>
>void ERR_put_error(int lib, int func, int reason, const char *file, int line);
>void ERR_set_error_data(char *data, int flags);
>
>unsigned long ERR_get_error(void);
>unsigned long ERR_get_error_line(const char **file, int *line);
>unsigned long ERR_get_error_line_data(const char **file, int *line,
> const char **data, int *flags);
>unsigned long ERR_peek_error(void);
>unsigned long ERR_peek_error_line(const char **file, int *line);
>unsigned long ERR_peek_error_line_data(const char **file, int *line,
> const char **data, int *flags);
>unsigned long ERR_peek_last_error(void);
>unsigned long ERR_peek_last_error_line(const char **file, int *line);
>unsigned long ERR_peek_last_error_line_data(const char **file, int *line,
> const char **data, int *flags);
>void ERR_clear_error(void);
>char *ERR_error_string(unsigned long e, char *buf);
>void ERR_error_string_n(unsigned long e, char *buf, size_t len);
>const char *ERR_lib_error_string(unsigned long e);
>const char *ERR_func_error_string(unsigned long e);
>const char *ERR_reason_error_string(unsigned long e);
>void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
> void *u);
>
>void ERR_print_errors_fp(FILE *fp);
>
>void ERR_print_errors(BIO *bp);
>void ERR_add_error_data(int num, ...);
>void ERR_add_error_vdata(int num, va_list args);
>int ERR_load_strings(int lib, ERR_STRING_DATA str[]);
>int ERR_unload_strings(int lib, ERR_STRING_DATA str[]);
>int ERR_load_ERR_strings(void);
>
>
>
>
>
>
>
>void ERR_remove_thread_state(void *) __attribute__ ((deprecated));
>void ERR_remove_state(unsigned long pid) __attribute__ ((deprecated));
>ERR_STATE *ERR_get_state(void);
>
>int ERR_get_next_error_library(void);
>
>int ERR_set_mark(void);
>int ERR_pop_to_mark(void);
>
>
>}
># 31 "/usr/include/openssl/engine.h" 2 3 4
>
>
>
>
>
>extern "C" {
># 255 "/usr/include/openssl/engine.h" 3 4
>typedef struct ENGINE_CMD_DEFN_st {
> unsigned int cmd_num;
> const char *cmd_name;
> const char *cmd_desc;
> unsigned int cmd_flags;
>} ENGINE_CMD_DEFN;
>
>
>typedef int (*ENGINE_GEN_FUNC_PTR) (void);
>
>typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *);
>
>typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *,
> void (*f) (void));
>
>typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
> UI_METHOD *ui_method,
> void *callback_data);
>typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
> struct stack_st_X509_NAME *ca_dn,
> X509 **pcert, EVP_PKEY **pkey,
> struct stack_st_X509 **pother,
> UI_METHOD *ui_method,
> void *callback_data);
># 294 "/usr/include/openssl/engine.h" 3 4
>typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **,
> const int **, int);
>typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
> int);
>typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **,
> const int **, int);
>typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
> const int **, int);
># 315 "/usr/include/openssl/engine.h" 3 4
>ENGINE *ENGINE_get_first(void);
>ENGINE *ENGINE_get_last(void);
>
>ENGINE *ENGINE_get_next(ENGINE *e);
>ENGINE *ENGINE_get_prev(ENGINE *e);
>
>int ENGINE_add(ENGINE *e);
>
>int ENGINE_remove(ENGINE *e);
>
>ENGINE *ENGINE_by_id(const char *id);
># 345 "/usr/include/openssl/engine.h" 3 4
>void ENGINE_load_builtin_engines(void);
>
>
>
>
>
>unsigned int ENGINE_get_table_flags(void);
>void ENGINE_set_table_flags(unsigned int flags);
># 362 "/usr/include/openssl/engine.h" 3 4
>int ENGINE_register_RSA(ENGINE *e);
>void ENGINE_unregister_RSA(ENGINE *e);
>void ENGINE_register_all_RSA(void);
>
>int ENGINE_register_DSA(ENGINE *e);
>void ENGINE_unregister_DSA(ENGINE *e);
>void ENGINE_register_all_DSA(void);
>
>int ENGINE_register_EC(ENGINE *e);
>void ENGINE_unregister_EC(ENGINE *e);
>void ENGINE_register_all_EC(void);
>
>int ENGINE_register_DH(ENGINE *e);
>void ENGINE_unregister_DH(ENGINE *e);
>void ENGINE_register_all_DH(void);
>
>int ENGINE_register_RAND(ENGINE *e);
>void ENGINE_unregister_RAND(ENGINE *e);
>void ENGINE_register_all_RAND(void);
>
>int ENGINE_register_ciphers(ENGINE *e);
>void ENGINE_unregister_ciphers(ENGINE *e);
>void ENGINE_register_all_ciphers(void);
>
>int ENGINE_register_digests(ENGINE *e);
>void ENGINE_unregister_digests(ENGINE *e);
>void ENGINE_register_all_digests(void);
>
>int ENGINE_register_pkey_meths(ENGINE *e);
>void ENGINE_unregister_pkey_meths(ENGINE *e);
>void ENGINE_register_all_pkey_meths(void);
>
>int ENGINE_register_pkey_asn1_meths(ENGINE *e);
>void ENGINE_unregister_pkey_asn1_meths(ENGINE *e);
>void ENGINE_register_all_pkey_asn1_meths(void);
>
>
>
>
>
>
>
>int ENGINE_register_complete(ENGINE *e);
>int ENGINE_register_all_complete(void);
># 417 "/usr/include/openssl/engine.h" 3 4
>int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void));
>
>
>
>
>
>
>
>int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
>
>
>
>
>
>
>
>int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
> long i, void *p, void (*f) (void), int cmd_optional);
># 458 "/usr/include/openssl/engine.h" 3 4
>int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
> int cmd_optional);
># 469 "/usr/include/openssl/engine.h" 3 4
>ENGINE *ENGINE_new(void);
>int ENGINE_free(ENGINE *e);
>int ENGINE_up_ref(ENGINE *e);
>int ENGINE_set_id(ENGINE *e, const char *id);
>int ENGINE_set_name(ENGINE *e, const char *name);
>int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth);
>int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
>int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth);
>int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
>int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
>int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
>int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
>int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
>int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
>int ENGINE_set_load_privkey_function(ENGINE *e,
> ENGINE_LOAD_KEY_PTR loadpriv_f);
>int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
>int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
> ENGINE_SSL_CLIENT_CERT_PTR
> loadssl_f);
>int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
>int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
>int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
>int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
>int ENGINE_set_flags(ENGINE *e, int flags);
>int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns);
>
>
>
>int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
>void *ENGINE_get_ex_data(const ENGINE *e, int idx);
># 515 "/usr/include/openssl/engine.h" 3 4
>const char *ENGINE_get_id(const ENGINE *e);
>const char *ENGINE_get_name(const ENGINE *e);
>const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e);
>const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
>const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e);
>const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
>const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
>ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
>ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
>ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
>ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
>ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
>ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
>ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE
> *e);
>ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
>ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
>ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
>ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e);
>const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
>const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
>const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
>const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
>const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
> const char *str,
> int len);
>const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
> const char *str,
> int len);
>const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
>int ENGINE_get_flags(const ENGINE *e);
># 565 "/usr/include/openssl/engine.h" 3 4
>int ENGINE_init(ENGINE *e);
>
>
>
>
>
>int ENGINE_finish(ENGINE *e);
>
>
>
>
>
>
>EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
> UI_METHOD *ui_method, void *callback_data);
>EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
> UI_METHOD *ui_method, void *callback_data);
>int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s,
> struct stack_st_X509_NAME *ca_dn, X509 **pcert,
> EVP_PKEY **ppkey, struct stack_st_X509 **pother,
> UI_METHOD *ui_method, void *callback_data);
>
>
>
>
>
>
>
>ENGINE *ENGINE_get_default_RSA(void);
>
>ENGINE *ENGINE_get_default_DSA(void);
>ENGINE *ENGINE_get_default_EC(void);
>ENGINE *ENGINE_get_default_DH(void);
>ENGINE *ENGINE_get_default_RAND(void);
>
>
>
>
>ENGINE *ENGINE_get_cipher_engine(int nid);
>ENGINE *ENGINE_get_digest_engine(int nid);
>ENGINE *ENGINE_get_pkey_meth_engine(int nid);
>ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid);
>
>
>
>
>
>
>
>int ENGINE_set_default_RSA(ENGINE *e);
>int ENGINE_set_default_string(ENGINE *e, const char *def_list);
>
>int ENGINE_set_default_DSA(ENGINE *e);
>int ENGINE_set_default_EC(ENGINE *e);
>int ENGINE_set_default_DH(ENGINE *e);
>int ENGINE_set_default_RAND(ENGINE *e);
>int ENGINE_set_default_ciphers(ENGINE *e);
>int ENGINE_set_default_digests(ENGINE *e);
>int ENGINE_set_default_pkey_meths(ENGINE *e);
>int ENGINE_set_default_pkey_asn1_meths(ENGINE *e);
># 633 "/usr/include/openssl/engine.h" 3 4
>int ENGINE_set_default(ENGINE *e, unsigned int flags);
>
>void ENGINE_add_conf_module(void);
># 663 "/usr/include/openssl/engine.h" 3 4
>typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int);
>typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int);
>typedef void (*dyn_MEM_free_fn) (void *, const char *, int);
>typedef struct st_dynamic_MEM_fns {
> dyn_MEM_malloc_fn malloc_fn;
> dyn_MEM_realloc_fn realloc_fn;
> dyn_MEM_free_fn free_fn;
>} dynamic_MEM_fns;
>
>
>
>
>
>typedef struct st_dynamic_fns {
> void *static_state;
> dynamic_MEM_fns mem_fns;
>} dynamic_fns;
># 693 "/usr/include/openssl/engine.h" 3 4
>typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version);
># 718 "/usr/include/openssl/engine.h" 3 4
>typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
> const dynamic_fns *fns);
># 744 "/usr/include/openssl/engine.h" 3 4
>void *ENGINE_get_static_state(void);
># 756 "/usr/include/openssl/engine.h" 3 4
>int ERR_load_ENGINE_strings(void);
># 837 "/usr/include/openssl/engine.h" 3 4
>}
># 24 "/usr/include/boost/asio/ssl/detail/openssl_types.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/openssl/x509v3.h" 1 3 4
># 18 "/usr/include/openssl/x509v3.h" 3 4
>extern "C" {
>
>
>
>struct v3_ext_method;
>struct v3_ext_ctx;
>
>
>
>typedef void *(*X509V3_EXT_NEW)(void);
>typedef void (*X509V3_EXT_FREE) (void *);
>typedef void *(*X509V3_EXT_D2I)(void *, const unsigned char **, long);
>typedef int (*X509V3_EXT_I2D) (void *, unsigned char **);
>typedef struct stack_st_CONF_VALUE *
> (*X509V3_EXT_I2V) (const struct v3_ext_method *method, void *ext,
> struct stack_st_CONF_VALUE *extlist);
>typedef void *(*X509V3_EXT_V2I)(const struct v3_ext_method *method,
> struct v3_ext_ctx *ctx,
> struct stack_st_CONF_VALUE *values);
>typedef char *(*X509V3_EXT_I2S)(const struct v3_ext_method *method,
> void *ext);
>typedef void *(*X509V3_EXT_S2I)(const struct v3_ext_method *method,
> struct v3_ext_ctx *ctx, const char *str);
>typedef int (*X509V3_EXT_I2R) (const struct v3_ext_method *method, void *ext,
> BIO *out, int indent);
>typedef void *(*X509V3_EXT_R2I)(const struct v3_ext_method *method,
> struct v3_ext_ctx *ctx, const char *str);
>
>
>
>struct v3_ext_method {
> int ext_nid;
> int ext_flags;
>
> ASN1_ITEM_EXP *it;
>
> X509V3_EXT_NEW ext_new;
> X509V3_EXT_FREE ext_free;
> X509V3_EXT_D2I d2i;
> X509V3_EXT_I2D i2d;
>
> X509V3_EXT_I2S i2s;
> X509V3_EXT_S2I s2i;
>
> X509V3_EXT_I2V i2v;
> X509V3_EXT_V2I v2i;
>
> X509V3_EXT_I2R i2r;
> X509V3_EXT_R2I r2i;
> void *usr_data;
>};
>
>typedef struct X509V3_CONF_METHOD_st {
> char *(*get_string) (void *db, const char *section, const char *value);
> struct stack_st_CONF_VALUE *(*get_section) (void *db, const char *section);
> void (*free_string) (void *db, char *string);
> void (*free_section) (void *db, struct stack_st_CONF_VALUE *section);
>} X509V3_CONF_METHOD;
>
>
>struct v3_ext_ctx {
>
>
> int flags;
> X509 *issuer_cert;
> X509 *subject_cert;
> X509_REQ *subject_req;
> X509_CRL *crl;
> X509V3_CONF_METHOD *db_meth;
> void *db;
>
>};
>
>typedef struct v3_ext_method X509V3_EXT_METHOD;
>
>struct stack_st_X509V3_EXT_METHOD; typedef int (*sk_X509V3_EXT_METHOD_compfunc)(const X509V3_EXT_METHOD * const *a, const X509V3_EXT_METHOD *const *b); typedef void (*sk_X509V3_EXT_METHOD_freefunc)(X509V3_EXT_METHOD *a); typedef X509V3_EXT_METHOD * (*sk_X509V3_EXT_METHOD_copyfunc)(const X509V3_EXT_METHOD *a); static inline int sk_X509V3_EXT_METHOD_num(const struct stack_st_X509V3_EXT_METHOD *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_value(const struct stack_st_X509V3_EXT_METHOD *sk, int idx) { return (X509V3_EXT_METHOD *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_new(sk_X509V3_EXT_METHOD_compfunc compare) { return (struct stack_st_X509V3_EXT_METHOD *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_new_null(void) { return (struct stack_st_X509V3_EXT_METHOD *)OPENSSL_sk_new_null(); } static inline void sk_X509V3_EXT_METHOD_free(struct stack_st_X509V3_EXT_METHOD *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509V3_EXT_METHOD_zero(struct stack_st_X509V3_EXT_METHOD *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_delete(struct stack_st_X509V3_EXT_METHOD *sk, int i) { return (X509V3_EXT_METHOD *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_delete_ptr(struct stack_st_X509V3_EXT_METHOD *sk, X509V3_EXT_METHOD *ptr) { return (X509V3_EXT_METHOD *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509V3_EXT_METHOD_push(struct stack_st_X509V3_EXT_METHOD *sk, X509V3_EXT_METHOD *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509V3_EXT_METHOD_unshift(struct stack_st_X509V3_EXT_METHOD *sk, X509V3_EXT_METHOD *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_pop(struct stack_st_X509V3_EXT_METHOD *sk) { return (X509V3_EXT_METHOD *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_shift(struct stack_st_X509V3_EXT_METHOD *sk) { return (X509V3_EXT_METHOD *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509V3_EXT_METHOD_pop_free(struct stack_st_X509V3_EXT_METHOD *sk, sk_X509V3_EXT_METHOD_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509V3_EXT_METHOD_insert(struct stack_st_X509V3_EXT_METHOD *sk, X509V3_EXT_METHOD *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_set(struct stack_st_X509V3_EXT_METHOD *sk, int idx, X509V3_EXT_METHOD *ptr) { return (X509V3_EXT_METHOD *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509V3_EXT_METHOD_find(struct stack_st_X509V3_EXT_METHOD *sk, X509V3_EXT_METHOD *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509V3_EXT_METHOD_find_ex(struct stack_st_X509V3_EXT_METHOD *sk, X509V3_EXT_METHOD *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509V3_EXT_METHOD_sort(struct stack_st_X509V3_EXT_METHOD *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509V3_EXT_METHOD_is_sorted(const struct stack_st_X509V3_EXT_METHOD *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509V3_EXT_METHOD * sk_X509V3_EXT_METHOD_dup(const struct stack_st_X509V3_EXT_METHOD *sk) { return (struct stack_st_X509V3_EXT_METHOD *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509V3_EXT_METHOD *sk_X509V3_EXT_METHOD_deep_copy(const struct stack_st_X509V3_EXT_METHOD *sk, sk_X509V3_EXT_METHOD_copyfunc copyfunc, sk_X509V3_EXT_METHOD_freefunc freefunc) { return (struct stack_st_X509V3_EXT_METHOD *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509V3_EXT_METHOD_compfunc sk_X509V3_EXT_METHOD_set_cmp_func(struct stack_st_X509V3_EXT_METHOD *sk, sk_X509V3_EXT_METHOD_compfunc compare) { return (sk_X509V3_EXT_METHOD_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>
>
>
>typedef BIT_STRING_BITNAME ENUMERATED_NAMES;
>
>typedef struct BASIC_CONSTRAINTS_st {
> int ca;
> ASN1_INTEGER *pathlen;
>} BASIC_CONSTRAINTS;
>
>typedef struct PKEY_USAGE_PERIOD_st {
> ASN1_GENERALIZEDTIME *notBefore;
> ASN1_GENERALIZEDTIME *notAfter;
>} PKEY_USAGE_PERIOD;
>
>typedef struct otherName_st {
> ASN1_OBJECT *type_id;
> ASN1_TYPE *value;
>} OTHERNAME;
>
>typedef struct EDIPartyName_st {
> ASN1_STRING *nameAssigner;
> ASN1_STRING *partyName;
>} EDIPARTYNAME;
>
>typedef struct GENERAL_NAME_st {
># 132 "/usr/include/openssl/x509v3.h" 3 4
> int type;
> union {
> char *ptr;
> OTHERNAME *otherName;
> ASN1_IA5STRING *rfc822Name;
> ASN1_IA5STRING *dNSName;
> ASN1_TYPE *x400Address;
> X509_NAME *directoryName;
> EDIPARTYNAME *ediPartyName;
> ASN1_IA5STRING *uniformResourceIdentifier;
> ASN1_OCTET_STRING *iPAddress;
> ASN1_OBJECT *registeredID;
>
> ASN1_OCTET_STRING *ip;
> X509_NAME *dirn;
> ASN1_IA5STRING *ia5;
>
> ASN1_OBJECT *rid;
> ASN1_TYPE *other;
> } d;
>} GENERAL_NAME;
>
>typedef struct ACCESS_DESCRIPTION_st {
> ASN1_OBJECT *method;
> GENERAL_NAME *location;
>} ACCESS_DESCRIPTION;
>
>typedef struct stack_st_ACCESS_DESCRIPTION AUTHORITY_INFO_ACCESS;
>
>typedef struct stack_st_ASN1_OBJECT EXTENDED_KEY_USAGE;
>
>typedef struct stack_st_ASN1_INTEGER TLS_FEATURE;
>
>struct stack_st_GENERAL_NAME; typedef int (*sk_GENERAL_NAME_compfunc)(const GENERAL_NAME * const *a, const GENERAL_NAME *const *b); typedef void (*sk_GENERAL_NAME_freefunc)(GENERAL_NAME *a); typedef GENERAL_NAME * (*sk_GENERAL_NAME_copyfunc)(const GENERAL_NAME *a); static inline int sk_GENERAL_NAME_num(const struct stack_st_GENERAL_NAME *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline GENERAL_NAME *sk_GENERAL_NAME_value(const struct stack_st_GENERAL_NAME *sk, int idx) { return (GENERAL_NAME *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_GENERAL_NAME *sk_GENERAL_NAME_new(sk_GENERAL_NAME_compfunc compare) { return (struct stack_st_GENERAL_NAME *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_GENERAL_NAME *sk_GENERAL_NAME_new_null(void) { return (struct stack_st_GENERAL_NAME *)OPENSSL_sk_new_null(); } static inline void sk_GENERAL_NAME_free(struct stack_st_GENERAL_NAME *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_GENERAL_NAME_zero(struct stack_st_GENERAL_NAME *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline GENERAL_NAME *sk_GENERAL_NAME_delete(struct stack_st_GENERAL_NAME *sk, int i) { return (GENERAL_NAME *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline GENERAL_NAME *sk_GENERAL_NAME_delete_ptr(struct stack_st_GENERAL_NAME *sk, GENERAL_NAME *ptr) { return (GENERAL_NAME *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_NAME_push(struct stack_st_GENERAL_NAME *sk, GENERAL_NAME *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_NAME_unshift(struct stack_st_GENERAL_NAME *sk, GENERAL_NAME *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline GENERAL_NAME *sk_GENERAL_NAME_pop(struct stack_st_GENERAL_NAME *sk) { return (GENERAL_NAME *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline GENERAL_NAME *sk_GENERAL_NAME_shift(struct stack_st_GENERAL_NAME *sk) { return (GENERAL_NAME *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_GENERAL_NAME_pop_free(struct stack_st_GENERAL_NAME *sk, sk_GENERAL_NAME_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_GENERAL_NAME_insert(struct stack_st_GENERAL_NAME *sk, GENERAL_NAME *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline GENERAL_NAME *sk_GENERAL_NAME_set(struct stack_st_GENERAL_NAME *sk, int idx, GENERAL_NAME *ptr) { return (GENERAL_NAME *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_GENERAL_NAME_find(struct stack_st_GENERAL_NAME *sk, GENERAL_NAME *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_NAME_find_ex(struct stack_st_GENERAL_NAME *sk, GENERAL_NAME *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_GENERAL_NAME_sort(struct stack_st_GENERAL_NAME *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_GENERAL_NAME_is_sorted(const struct stack_st_GENERAL_NAME *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_GENERAL_NAME * sk_GENERAL_NAME_dup(const struct stack_st_GENERAL_NAME *sk) { return (struct stack_st_GENERAL_NAME *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_GENERAL_NAME *sk_GENERAL_NAME_deep_copy(const struct stack_st_GENERAL_NAME *sk, sk_GENERAL_NAME_copyfunc copyfunc, sk_GENERAL_NAME_freefunc freefunc) { return (struct stack_st_GENERAL_NAME *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_GENERAL_NAME_compfunc sk_GENERAL_NAME_set_cmp_func(struct stack_st_GENERAL_NAME *sk, sk_GENERAL_NAME_compfunc compare) { return (sk_GENERAL_NAME_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>typedef struct stack_st_GENERAL_NAME GENERAL_NAMES;
>struct stack_st_GENERAL_NAMES; typedef int (*sk_GENERAL_NAMES_compfunc)(const GENERAL_NAMES * const *a, const GENERAL_NAMES *const *b); typedef void (*sk_GENERAL_NAMES_freefunc)(GENERAL_NAMES *a); typedef GENERAL_NAMES * (*sk_GENERAL_NAMES_copyfunc)(const GENERAL_NAMES *a); static inline int sk_GENERAL_NAMES_num(const struct stack_st_GENERAL_NAMES *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline GENERAL_NAMES *sk_GENERAL_NAMES_value(const struct stack_st_GENERAL_NAMES *sk, int idx) { return (GENERAL_NAMES *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_GENERAL_NAMES *sk_GENERAL_NAMES_new(sk_GENERAL_NAMES_compfunc compare) { return (struct stack_st_GENERAL_NAMES *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_GENERAL_NAMES *sk_GENERAL_NAMES_new_null(void) { return (struct stack_st_GENERAL_NAMES *)OPENSSL_sk_new_null(); } static inline void sk_GENERAL_NAMES_free(struct stack_st_GENERAL_NAMES *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_GENERAL_NAMES_zero(struct stack_st_GENERAL_NAMES *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline GENERAL_NAMES *sk_GENERAL_NAMES_delete(struct stack_st_GENERAL_NAMES *sk, int i) { return (GENERAL_NAMES *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline GENERAL_NAMES *sk_GENERAL_NAMES_delete_ptr(struct stack_st_GENERAL_NAMES *sk, GENERAL_NAMES *ptr) { return (GENERAL_NAMES *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_NAMES_push(struct stack_st_GENERAL_NAMES *sk, GENERAL_NAMES *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_NAMES_unshift(struct stack_st_GENERAL_NAMES *sk, GENERAL_NAMES *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline GENERAL_NAMES *sk_GENERAL_NAMES_pop(struct stack_st_GENERAL_NAMES *sk) { return (GENERAL_NAMES *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline GENERAL_NAMES *sk_GENERAL_NAMES_shift(struct stack_st_GENERAL_NAMES *sk) { return (GENERAL_NAMES *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_GENERAL_NAMES_pop_free(struct stack_st_GENERAL_NAMES *sk, sk_GENERAL_NAMES_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_GENERAL_NAMES_insert(struct stack_st_GENERAL_NAMES *sk, GENERAL_NAMES *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline GENERAL_NAMES *sk_GENERAL_NAMES_set(struct stack_st_GENERAL_NAMES *sk, int idx, GENERAL_NAMES *ptr) { return (GENERAL_NAMES *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_GENERAL_NAMES_find(struct stack_st_GENERAL_NAMES *sk, GENERAL_NAMES *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_NAMES_find_ex(struct stack_st_GENERAL_NAMES *sk, GENERAL_NAMES *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_GENERAL_NAMES_sort(struct stack_st_GENERAL_NAMES *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_GENERAL_NAMES_is_sorted(const struct stack_st_GENERAL_NAMES *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_GENERAL_NAMES * sk_GENERAL_NAMES_dup(const struct stack_st_GENERAL_NAMES *sk) { return (struct stack_st_GENERAL_NAMES *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_GENERAL_NAMES *sk_GENERAL_NAMES_deep_copy(const struct stack_st_GENERAL_NAMES *sk, sk_GENERAL_NAMES_copyfunc copyfunc, sk_GENERAL_NAMES_freefunc freefunc) { return (struct stack_st_GENERAL_NAMES *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_GENERAL_NAMES_compfunc sk_GENERAL_NAMES_set_cmp_func(struct stack_st_GENERAL_NAMES *sk, sk_GENERAL_NAMES_compfunc compare) { return (sk_GENERAL_NAMES_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>struct stack_st_ACCESS_DESCRIPTION; typedef int (*sk_ACCESS_DESCRIPTION_compfunc)(const ACCESS_DESCRIPTION * const *a, const ACCESS_DESCRIPTION *const *b); typedef void (*sk_ACCESS_DESCRIPTION_freefunc)(ACCESS_DESCRIPTION *a); typedef ACCESS_DESCRIPTION * (*sk_ACCESS_DESCRIPTION_copyfunc)(const ACCESS_DESCRIPTION *a); static inline int sk_ACCESS_DESCRIPTION_num(const struct stack_st_ACCESS_DESCRIPTION *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_value(const struct stack_st_ACCESS_DESCRIPTION *sk, int idx) { return (ACCESS_DESCRIPTION *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_new(sk_ACCESS_DESCRIPTION_compfunc compare) { return (struct stack_st_ACCESS_DESCRIPTION *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_new_null(void) { return (struct stack_st_ACCESS_DESCRIPTION *)OPENSSL_sk_new_null(); } static inline void sk_ACCESS_DESCRIPTION_free(struct stack_st_ACCESS_DESCRIPTION *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ACCESS_DESCRIPTION_zero(struct stack_st_ACCESS_DESCRIPTION *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_delete(struct stack_st_ACCESS_DESCRIPTION *sk, int i) { return (ACCESS_DESCRIPTION *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_delete_ptr(struct stack_st_ACCESS_DESCRIPTION *sk, ACCESS_DESCRIPTION *ptr) { return (ACCESS_DESCRIPTION *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ACCESS_DESCRIPTION_push(struct stack_st_ACCESS_DESCRIPTION *sk, ACCESS_DESCRIPTION *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ACCESS_DESCRIPTION_unshift(struct stack_st_ACCESS_DESCRIPTION *sk, ACCESS_DESCRIPTION *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_pop(struct stack_st_ACCESS_DESCRIPTION *sk) { return (ACCESS_DESCRIPTION *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_shift(struct stack_st_ACCESS_DESCRIPTION *sk) { return (ACCESS_DESCRIPTION *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ACCESS_DESCRIPTION_pop_free(struct stack_st_ACCESS_DESCRIPTION *sk, sk_ACCESS_DESCRIPTION_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ACCESS_DESCRIPTION_insert(struct stack_st_ACCESS_DESCRIPTION *sk, ACCESS_DESCRIPTION *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_set(struct stack_st_ACCESS_DESCRIPTION *sk, int idx, ACCESS_DESCRIPTION *ptr) { return (ACCESS_DESCRIPTION *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ACCESS_DESCRIPTION_find(struct stack_st_ACCESS_DESCRIPTION *sk, ACCESS_DESCRIPTION *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ACCESS_DESCRIPTION_find_ex(struct stack_st_ACCESS_DESCRIPTION *sk, ACCESS_DESCRIPTION *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ACCESS_DESCRIPTION_sort(struct stack_st_ACCESS_DESCRIPTION *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ACCESS_DESCRIPTION_is_sorted(const struct stack_st_ACCESS_DESCRIPTION *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ACCESS_DESCRIPTION * sk_ACCESS_DESCRIPTION_dup(const struct stack_st_ACCESS_DESCRIPTION *sk) { return (struct stack_st_ACCESS_DESCRIPTION *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ACCESS_DESCRIPTION *sk_ACCESS_DESCRIPTION_deep_copy(const struct stack_st_ACCESS_DESCRIPTION *sk, sk_ACCESS_DESCRIPTION_copyfunc copyfunc, sk_ACCESS_DESCRIPTION_freefunc freefunc) { return (struct stack_st_ACCESS_DESCRIPTION *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ACCESS_DESCRIPTION_compfunc sk_ACCESS_DESCRIPTION_set_cmp_func(struct stack_st_ACCESS_DESCRIPTION *sk, sk_ACCESS_DESCRIPTION_compfunc compare) { return (sk_ACCESS_DESCRIPTION_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct DIST_POINT_NAME_st {
> int type;
> union {
> GENERAL_NAMES *fullname;
> struct stack_st_X509_NAME_ENTRY *relativename;
> } name;
>
> X509_NAME *dpname;
>} DIST_POINT_NAME;
># 195 "/usr/include/openssl/x509v3.h" 3 4
>struct DIST_POINT_st {
> DIST_POINT_NAME *distpoint;
> ASN1_BIT_STRING *reasons;
> GENERAL_NAMES *CRLissuer;
> int dp_reasons;
>};
>
>typedef struct stack_st_DIST_POINT CRL_DIST_POINTS;
>
>struct stack_st_DIST_POINT; typedef int (*sk_DIST_POINT_compfunc)(const DIST_POINT * const *a, const DIST_POINT *const *b); typedef void (*sk_DIST_POINT_freefunc)(DIST_POINT *a); typedef DIST_POINT * (*sk_DIST_POINT_copyfunc)(const DIST_POINT *a); static inline int sk_DIST_POINT_num(const struct stack_st_DIST_POINT *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline DIST_POINT *sk_DIST_POINT_value(const struct stack_st_DIST_POINT *sk, int idx) { return (DIST_POINT *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_DIST_POINT *sk_DIST_POINT_new(sk_DIST_POINT_compfunc compare) { return (struct stack_st_DIST_POINT *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_DIST_POINT *sk_DIST_POINT_new_null(void) { return (struct stack_st_DIST_POINT *)OPENSSL_sk_new_null(); } static inline void sk_DIST_POINT_free(struct stack_st_DIST_POINT *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_DIST_POINT_zero(struct stack_st_DIST_POINT *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline DIST_POINT *sk_DIST_POINT_delete(struct stack_st_DIST_POINT *sk, int i) { return (DIST_POINT *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline DIST_POINT *sk_DIST_POINT_delete_ptr(struct stack_st_DIST_POINT *sk, DIST_POINT *ptr) { return (DIST_POINT *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_DIST_POINT_push(struct stack_st_DIST_POINT *sk, DIST_POINT *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_DIST_POINT_unshift(struct stack_st_DIST_POINT *sk, DIST_POINT *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline DIST_POINT *sk_DIST_POINT_pop(struct stack_st_DIST_POINT *sk) { return (DIST_POINT *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline DIST_POINT *sk_DIST_POINT_shift(struct stack_st_DIST_POINT *sk) { return (DIST_POINT *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_DIST_POINT_pop_free(struct stack_st_DIST_POINT *sk, sk_DIST_POINT_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_DIST_POINT_insert(struct stack_st_DIST_POINT *sk, DIST_POINT *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline DIST_POINT *sk_DIST_POINT_set(struct stack_st_DIST_POINT *sk, int idx, DIST_POINT *ptr) { return (DIST_POINT *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_DIST_POINT_find(struct stack_st_DIST_POINT *sk, DIST_POINT *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_DIST_POINT_find_ex(struct stack_st_DIST_POINT *sk, DIST_POINT *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_DIST_POINT_sort(struct stack_st_DIST_POINT *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_DIST_POINT_is_sorted(const struct stack_st_DIST_POINT *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_DIST_POINT * sk_DIST_POINT_dup(const struct stack_st_DIST_POINT *sk) { return (struct stack_st_DIST_POINT *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_DIST_POINT *sk_DIST_POINT_deep_copy(const struct stack_st_DIST_POINT *sk, sk_DIST_POINT_copyfunc copyfunc, sk_DIST_POINT_freefunc freefunc) { return (struct stack_st_DIST_POINT *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_DIST_POINT_compfunc sk_DIST_POINT_set_cmp_func(struct stack_st_DIST_POINT *sk, sk_DIST_POINT_compfunc compare) { return (sk_DIST_POINT_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>struct AUTHORITY_KEYID_st {
> ASN1_OCTET_STRING *keyid;
> GENERAL_NAMES *issuer;
> ASN1_INTEGER *serial;
>};
>
>
>
>typedef struct SXNET_ID_st {
> ASN1_INTEGER *zone;
> ASN1_OCTET_STRING *user;
>} SXNETID;
>
>struct stack_st_SXNETID; typedef int (*sk_SXNETID_compfunc)(const SXNETID * const *a, const SXNETID *const *b); typedef void (*sk_SXNETID_freefunc)(SXNETID *a); typedef SXNETID * (*sk_SXNETID_copyfunc)(const SXNETID *a); static inline int sk_SXNETID_num(const struct stack_st_SXNETID *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline SXNETID *sk_SXNETID_value(const struct stack_st_SXNETID *sk, int idx) { return (SXNETID *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_SXNETID *sk_SXNETID_new(sk_SXNETID_compfunc compare) { return (struct stack_st_SXNETID *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_SXNETID *sk_SXNETID_new_null(void) { return (struct stack_st_SXNETID *)OPENSSL_sk_new_null(); } static inline void sk_SXNETID_free(struct stack_st_SXNETID *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_SXNETID_zero(struct stack_st_SXNETID *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline SXNETID *sk_SXNETID_delete(struct stack_st_SXNETID *sk, int i) { return (SXNETID *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline SXNETID *sk_SXNETID_delete_ptr(struct stack_st_SXNETID *sk, SXNETID *ptr) { return (SXNETID *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SXNETID_push(struct stack_st_SXNETID *sk, SXNETID *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SXNETID_unshift(struct stack_st_SXNETID *sk, SXNETID *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline SXNETID *sk_SXNETID_pop(struct stack_st_SXNETID *sk) { return (SXNETID *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline SXNETID *sk_SXNETID_shift(struct stack_st_SXNETID *sk) { return (SXNETID *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_SXNETID_pop_free(struct stack_st_SXNETID *sk, sk_SXNETID_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_SXNETID_insert(struct stack_st_SXNETID *sk, SXNETID *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline SXNETID *sk_SXNETID_set(struct stack_st_SXNETID *sk, int idx, SXNETID *ptr) { return (SXNETID *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_SXNETID_find(struct stack_st_SXNETID *sk, SXNETID *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_SXNETID_find_ex(struct stack_st_SXNETID *sk, SXNETID *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_SXNETID_sort(struct stack_st_SXNETID *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_SXNETID_is_sorted(const struct stack_st_SXNETID *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_SXNETID * sk_SXNETID_dup(const struct stack_st_SXNETID *sk) { return (struct stack_st_SXNETID *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_SXNETID *sk_SXNETID_deep_copy(const struct stack_st_SXNETID *sk, sk_SXNETID_copyfunc copyfunc, sk_SXNETID_freefunc freefunc) { return (struct stack_st_SXNETID *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_SXNETID_compfunc sk_SXNETID_set_cmp_func(struct stack_st_SXNETID *sk, sk_SXNETID_compfunc compare) { return (sk_SXNETID_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct SXNET_st {
> ASN1_INTEGER *version;
> struct stack_st_SXNETID *ids;
>} SXNET;
>
>typedef struct NOTICEREF_st {
> ASN1_STRING *organization;
> struct stack_st_ASN1_INTEGER *noticenos;
>} NOTICEREF;
>
>typedef struct USERNOTICE_st {
> NOTICEREF *noticeref;
> ASN1_STRING *exptext;
>} USERNOTICE;
>
>typedef struct POLICYQUALINFO_st {
> ASN1_OBJECT *pqualid;
> union {
> ASN1_IA5STRING *cpsuri;
> USERNOTICE *usernotice;
> ASN1_TYPE *other;
> } d;
>} POLICYQUALINFO;
>
>struct stack_st_POLICYQUALINFO; typedef int (*sk_POLICYQUALINFO_compfunc)(const POLICYQUALINFO * const *a, const POLICYQUALINFO *const *b); typedef void (*sk_POLICYQUALINFO_freefunc)(POLICYQUALINFO *a); typedef POLICYQUALINFO * (*sk_POLICYQUALINFO_copyfunc)(const POLICYQUALINFO *a); static inline int sk_POLICYQUALINFO_num(const struct stack_st_POLICYQUALINFO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline POLICYQUALINFO *sk_POLICYQUALINFO_value(const struct stack_st_POLICYQUALINFO *sk, int idx) { return (POLICYQUALINFO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_POLICYQUALINFO *sk_POLICYQUALINFO_new(sk_POLICYQUALINFO_compfunc compare) { return (struct stack_st_POLICYQUALINFO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_POLICYQUALINFO *sk_POLICYQUALINFO_new_null(void) { return (struct stack_st_POLICYQUALINFO *)OPENSSL_sk_new_null(); } static inline void sk_POLICYQUALINFO_free(struct stack_st_POLICYQUALINFO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_POLICYQUALINFO_zero(struct stack_st_POLICYQUALINFO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline POLICYQUALINFO *sk_POLICYQUALINFO_delete(struct stack_st_POLICYQUALINFO *sk, int i) { return (POLICYQUALINFO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline POLICYQUALINFO *sk_POLICYQUALINFO_delete_ptr(struct stack_st_POLICYQUALINFO *sk, POLICYQUALINFO *ptr) { return (POLICYQUALINFO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICYQUALINFO_push(struct stack_st_POLICYQUALINFO *sk, POLICYQUALINFO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICYQUALINFO_unshift(struct stack_st_POLICYQUALINFO *sk, POLICYQUALINFO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline POLICYQUALINFO *sk_POLICYQUALINFO_pop(struct stack_st_POLICYQUALINFO *sk) { return (POLICYQUALINFO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline POLICYQUALINFO *sk_POLICYQUALINFO_shift(struct stack_st_POLICYQUALINFO *sk) { return (POLICYQUALINFO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_POLICYQUALINFO_pop_free(struct stack_st_POLICYQUALINFO *sk, sk_POLICYQUALINFO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_POLICYQUALINFO_insert(struct stack_st_POLICYQUALINFO *sk, POLICYQUALINFO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline POLICYQUALINFO *sk_POLICYQUALINFO_set(struct stack_st_POLICYQUALINFO *sk, int idx, POLICYQUALINFO *ptr) { return (POLICYQUALINFO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_POLICYQUALINFO_find(struct stack_st_POLICYQUALINFO *sk, POLICYQUALINFO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICYQUALINFO_find_ex(struct stack_st_POLICYQUALINFO *sk, POLICYQUALINFO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_POLICYQUALINFO_sort(struct stack_st_POLICYQUALINFO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_POLICYQUALINFO_is_sorted(const struct stack_st_POLICYQUALINFO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_POLICYQUALINFO * sk_POLICYQUALINFO_dup(const struct stack_st_POLICYQUALINFO *sk) { return (struct stack_st_POLICYQUALINFO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_POLICYQUALINFO *sk_POLICYQUALINFO_deep_copy(const struct stack_st_POLICYQUALINFO *sk, sk_POLICYQUALINFO_copyfunc copyfunc, sk_POLICYQUALINFO_freefunc freefunc) { return (struct stack_st_POLICYQUALINFO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_POLICYQUALINFO_compfunc sk_POLICYQUALINFO_set_cmp_func(struct stack_st_POLICYQUALINFO *sk, sk_POLICYQUALINFO_compfunc compare) { return (sk_POLICYQUALINFO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct POLICYINFO_st {
> ASN1_OBJECT *policyid;
> struct stack_st_POLICYQUALINFO *qualifiers;
>} POLICYINFO;
>
>typedef struct stack_st_POLICYINFO CERTIFICATEPOLICIES;
>
>struct stack_st_POLICYINFO; typedef int (*sk_POLICYINFO_compfunc)(const POLICYINFO * const *a, const POLICYINFO *const *b); typedef void (*sk_POLICYINFO_freefunc)(POLICYINFO *a); typedef POLICYINFO * (*sk_POLICYINFO_copyfunc)(const POLICYINFO *a); static inline int sk_POLICYINFO_num(const struct stack_st_POLICYINFO *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline POLICYINFO *sk_POLICYINFO_value(const struct stack_st_POLICYINFO *sk, int idx) { return (POLICYINFO *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_POLICYINFO *sk_POLICYINFO_new(sk_POLICYINFO_compfunc compare) { return (struct stack_st_POLICYINFO *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_POLICYINFO *sk_POLICYINFO_new_null(void) { return (struct stack_st_POLICYINFO *)OPENSSL_sk_new_null(); } static inline void sk_POLICYINFO_free(struct stack_st_POLICYINFO *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_POLICYINFO_zero(struct stack_st_POLICYINFO *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline POLICYINFO *sk_POLICYINFO_delete(struct stack_st_POLICYINFO *sk, int i) { return (POLICYINFO *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline POLICYINFO *sk_POLICYINFO_delete_ptr(struct stack_st_POLICYINFO *sk, POLICYINFO *ptr) { return (POLICYINFO *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICYINFO_push(struct stack_st_POLICYINFO *sk, POLICYINFO *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICYINFO_unshift(struct stack_st_POLICYINFO *sk, POLICYINFO *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline POLICYINFO *sk_POLICYINFO_pop(struct stack_st_POLICYINFO *sk) { return (POLICYINFO *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline POLICYINFO *sk_POLICYINFO_shift(struct stack_st_POLICYINFO *sk) { return (POLICYINFO *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_POLICYINFO_pop_free(struct stack_st_POLICYINFO *sk, sk_POLICYINFO_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_POLICYINFO_insert(struct stack_st_POLICYINFO *sk, POLICYINFO *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline POLICYINFO *sk_POLICYINFO_set(struct stack_st_POLICYINFO *sk, int idx, POLICYINFO *ptr) { return (POLICYINFO *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_POLICYINFO_find(struct stack_st_POLICYINFO *sk, POLICYINFO *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICYINFO_find_ex(struct stack_st_POLICYINFO *sk, POLICYINFO *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_POLICYINFO_sort(struct stack_st_POLICYINFO *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_POLICYINFO_is_sorted(const struct stack_st_POLICYINFO *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_POLICYINFO * sk_POLICYINFO_dup(const struct stack_st_POLICYINFO *sk) { return (struct stack_st_POLICYINFO *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_POLICYINFO *sk_POLICYINFO_deep_copy(const struct stack_st_POLICYINFO *sk, sk_POLICYINFO_copyfunc copyfunc, sk_POLICYINFO_freefunc freefunc) { return (struct stack_st_POLICYINFO *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_POLICYINFO_compfunc sk_POLICYINFO_set_cmp_func(struct stack_st_POLICYINFO *sk, sk_POLICYINFO_compfunc compare) { return (sk_POLICYINFO_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct POLICY_MAPPING_st {
> ASN1_OBJECT *issuerDomainPolicy;
> ASN1_OBJECT *subjectDomainPolicy;
>} POLICY_MAPPING;
>
>struct stack_st_POLICY_MAPPING; typedef int (*sk_POLICY_MAPPING_compfunc)(const POLICY_MAPPING * const *a, const POLICY_MAPPING *const *b); typedef void (*sk_POLICY_MAPPING_freefunc)(POLICY_MAPPING *a); typedef POLICY_MAPPING * (*sk_POLICY_MAPPING_copyfunc)(const POLICY_MAPPING *a); static inline int sk_POLICY_MAPPING_num(const struct stack_st_POLICY_MAPPING *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline POLICY_MAPPING *sk_POLICY_MAPPING_value(const struct stack_st_POLICY_MAPPING *sk, int idx) { return (POLICY_MAPPING *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_POLICY_MAPPING *sk_POLICY_MAPPING_new(sk_POLICY_MAPPING_compfunc compare) { return (struct stack_st_POLICY_MAPPING *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_POLICY_MAPPING *sk_POLICY_MAPPING_new_null(void) { return (struct stack_st_POLICY_MAPPING *)OPENSSL_sk_new_null(); } static inline void sk_POLICY_MAPPING_free(struct stack_st_POLICY_MAPPING *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_POLICY_MAPPING_zero(struct stack_st_POLICY_MAPPING *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline POLICY_MAPPING *sk_POLICY_MAPPING_delete(struct stack_st_POLICY_MAPPING *sk, int i) { return (POLICY_MAPPING *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline POLICY_MAPPING *sk_POLICY_MAPPING_delete_ptr(struct stack_st_POLICY_MAPPING *sk, POLICY_MAPPING *ptr) { return (POLICY_MAPPING *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICY_MAPPING_push(struct stack_st_POLICY_MAPPING *sk, POLICY_MAPPING *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICY_MAPPING_unshift(struct stack_st_POLICY_MAPPING *sk, POLICY_MAPPING *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline POLICY_MAPPING *sk_POLICY_MAPPING_pop(struct stack_st_POLICY_MAPPING *sk) { return (POLICY_MAPPING *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline POLICY_MAPPING *sk_POLICY_MAPPING_shift(struct stack_st_POLICY_MAPPING *sk) { return (POLICY_MAPPING *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_POLICY_MAPPING_pop_free(struct stack_st_POLICY_MAPPING *sk, sk_POLICY_MAPPING_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_POLICY_MAPPING_insert(struct stack_st_POLICY_MAPPING *sk, POLICY_MAPPING *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline POLICY_MAPPING *sk_POLICY_MAPPING_set(struct stack_st_POLICY_MAPPING *sk, int idx, POLICY_MAPPING *ptr) { return (POLICY_MAPPING *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_POLICY_MAPPING_find(struct stack_st_POLICY_MAPPING *sk, POLICY_MAPPING *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_POLICY_MAPPING_find_ex(struct stack_st_POLICY_MAPPING *sk, POLICY_MAPPING *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_POLICY_MAPPING_sort(struct stack_st_POLICY_MAPPING *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_POLICY_MAPPING_is_sorted(const struct stack_st_POLICY_MAPPING *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_POLICY_MAPPING * sk_POLICY_MAPPING_dup(const struct stack_st_POLICY_MAPPING *sk) { return (struct stack_st_POLICY_MAPPING *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_POLICY_MAPPING *sk_POLICY_MAPPING_deep_copy(const struct stack_st_POLICY_MAPPING *sk, sk_POLICY_MAPPING_copyfunc copyfunc, sk_POLICY_MAPPING_freefunc freefunc) { return (struct stack_st_POLICY_MAPPING *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_POLICY_MAPPING_compfunc sk_POLICY_MAPPING_set_cmp_func(struct stack_st_POLICY_MAPPING *sk, sk_POLICY_MAPPING_compfunc compare) { return (sk_POLICY_MAPPING_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>typedef struct stack_st_POLICY_MAPPING POLICY_MAPPINGS;
>
>typedef struct GENERAL_SUBTREE_st {
> GENERAL_NAME *base;
> ASN1_INTEGER *minimum;
> ASN1_INTEGER *maximum;
>} GENERAL_SUBTREE;
>
>struct stack_st_GENERAL_SUBTREE; typedef int (*sk_GENERAL_SUBTREE_compfunc)(const GENERAL_SUBTREE * const *a, const GENERAL_SUBTREE *const *b); typedef void (*sk_GENERAL_SUBTREE_freefunc)(GENERAL_SUBTREE *a); typedef GENERAL_SUBTREE * (*sk_GENERAL_SUBTREE_copyfunc)(const GENERAL_SUBTREE *a); static inline int sk_GENERAL_SUBTREE_num(const struct stack_st_GENERAL_SUBTREE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline GENERAL_SUBTREE *sk_GENERAL_SUBTREE_value(const struct stack_st_GENERAL_SUBTREE *sk, int idx) { return (GENERAL_SUBTREE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_GENERAL_SUBTREE *sk_GENERAL_SUBTREE_new(sk_GENERAL_SUBTREE_compfunc compare) { return (struct stack_st_GENERAL_SUBTREE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_GENERAL_SUBTREE *sk_GENERAL_SUBTREE_new_null(void) { return (struct stack_st_GENERAL_SUBTREE *)OPENSSL_sk_new_null(); } static inline void sk_GENERAL_SUBTREE_free(struct stack_st_GENERAL_SUBTREE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_GENERAL_SUBTREE_zero(struct stack_st_GENERAL_SUBTREE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline GENERAL_SUBTREE *sk_GENERAL_SUBTREE_delete(struct stack_st_GENERAL_SUBTREE *sk, int i) { return (GENERAL_SUBTREE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline GENERAL_SUBTREE *sk_GENERAL_SUBTREE_delete_ptr(struct stack_st_GENERAL_SUBTREE *sk, GENERAL_SUBTREE *ptr) { return (GENERAL_SUBTREE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_SUBTREE_push(struct stack_st_GENERAL_SUBTREE *sk, GENERAL_SUBTREE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_SUBTREE_unshift(struct stack_st_GENERAL_SUBTREE *sk, GENERAL_SUBTREE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline GENERAL_SUBTREE *sk_GENERAL_SUBTREE_pop(struct stack_st_GENERAL_SUBTREE *sk) { return (GENERAL_SUBTREE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline GENERAL_SUBTREE *sk_GENERAL_SUBTREE_shift(struct stack_st_GENERAL_SUBTREE *sk) { return (GENERAL_SUBTREE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_GENERAL_SUBTREE_pop_free(struct stack_st_GENERAL_SUBTREE *sk, sk_GENERAL_SUBTREE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_GENERAL_SUBTREE_insert(struct stack_st_GENERAL_SUBTREE *sk, GENERAL_SUBTREE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline GENERAL_SUBTREE *sk_GENERAL_SUBTREE_set(struct stack_st_GENERAL_SUBTREE *sk, int idx, GENERAL_SUBTREE *ptr) { return (GENERAL_SUBTREE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_GENERAL_SUBTREE_find(struct stack_st_GENERAL_SUBTREE *sk, GENERAL_SUBTREE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_GENERAL_SUBTREE_find_ex(struct stack_st_GENERAL_SUBTREE *sk, GENERAL_SUBTREE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_GENERAL_SUBTREE_sort(struct stack_st_GENERAL_SUBTREE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_GENERAL_SUBTREE_is_sorted(const struct stack_st_GENERAL_SUBTREE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_GENERAL_SUBTREE * sk_GENERAL_SUBTREE_dup(const struct stack_st_GENERAL_SUBTREE *sk) { return (struct stack_st_GENERAL_SUBTREE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_GENERAL_SUBTREE *sk_GENERAL_SUBTREE_deep_copy(const struct stack_st_GENERAL_SUBTREE *sk, sk_GENERAL_SUBTREE_copyfunc copyfunc, sk_GENERAL_SUBTREE_freefunc freefunc) { return (struct stack_st_GENERAL_SUBTREE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_GENERAL_SUBTREE_compfunc sk_GENERAL_SUBTREE_set_cmp_func(struct stack_st_GENERAL_SUBTREE *sk, sk_GENERAL_SUBTREE_compfunc compare) { return (sk_GENERAL_SUBTREE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>struct NAME_CONSTRAINTS_st {
> struct stack_st_GENERAL_SUBTREE *permittedSubtrees;
> struct stack_st_GENERAL_SUBTREE *excludedSubtrees;
>};
>
>typedef struct POLICY_CONSTRAINTS_st {
> ASN1_INTEGER *requireExplicitPolicy;
> ASN1_INTEGER *inhibitPolicyMapping;
>} POLICY_CONSTRAINTS;
>
>
>typedef struct PROXY_POLICY_st {
> ASN1_OBJECT *policyLanguage;
> ASN1_OCTET_STRING *policy;
>} PROXY_POLICY;
>
>typedef struct PROXY_CERT_INFO_EXTENSION_st {
> ASN1_INTEGER *pcPathLengthConstraint;
> PROXY_POLICY *proxyPolicy;
>} PROXY_CERT_INFO_EXTENSION;
>
>PROXY_POLICY *PROXY_POLICY_new(void); void PROXY_POLICY_free(PROXY_POLICY *a); PROXY_POLICY *d2i_PROXY_POLICY(PROXY_POLICY **a, const unsigned char **in, long len); int i2d_PROXY_POLICY(PROXY_POLICY *a, unsigned char **out); extern const ASN1_ITEM PROXY_POLICY_it;
>PROXY_CERT_INFO_EXTENSION *PROXY_CERT_INFO_EXTENSION_new(void); void PROXY_CERT_INFO_EXTENSION_free(PROXY_CERT_INFO_EXTENSION *a); PROXY_CERT_INFO_EXTENSION *d2i_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION **a, const unsigned char **in, long len); int i2d_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION *a, unsigned char **out); extern const ASN1_ITEM PROXY_CERT_INFO_EXTENSION_it;
>
>struct ISSUING_DIST_POINT_st {
> DIST_POINT_NAME *distpoint;
> int onlyuser;
> int onlyCA;
> ASN1_BIT_STRING *onlysomereasons;
> int indirectCRL;
> int onlyattr;
>};
># 400 "/usr/include/openssl/x509v3.h" 3 4
>typedef struct x509_purpose_st {
> int purpose;
> int trust;
> int flags;
> int (*check_purpose) (const struct x509_purpose_st *, const X509 *, int);
> char *name;
> char *sname;
> void *usr_data;
>} X509_PURPOSE;
># 446 "/usr/include/openssl/x509v3.h" 3 4
>struct stack_st_X509_PURPOSE; typedef int (*sk_X509_PURPOSE_compfunc)(const X509_PURPOSE * const *a, const X509_PURPOSE *const *b); typedef void (*sk_X509_PURPOSE_freefunc)(X509_PURPOSE *a); typedef X509_PURPOSE * (*sk_X509_PURPOSE_copyfunc)(const X509_PURPOSE *a); static inline int sk_X509_PURPOSE_num(const struct stack_st_X509_PURPOSE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_PURPOSE *sk_X509_PURPOSE_value(const struct stack_st_X509_PURPOSE *sk, int idx) { return (X509_PURPOSE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_PURPOSE *sk_X509_PURPOSE_new(sk_X509_PURPOSE_compfunc compare) { return (struct stack_st_X509_PURPOSE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_PURPOSE *sk_X509_PURPOSE_new_null(void) { return (struct stack_st_X509_PURPOSE *)OPENSSL_sk_new_null(); } static inline void sk_X509_PURPOSE_free(struct stack_st_X509_PURPOSE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_PURPOSE_zero(struct stack_st_X509_PURPOSE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_PURPOSE *sk_X509_PURPOSE_delete(struct stack_st_X509_PURPOSE *sk, int i) { return (X509_PURPOSE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_PURPOSE *sk_X509_PURPOSE_delete_ptr(struct stack_st_X509_PURPOSE *sk, X509_PURPOSE *ptr) { return (X509_PURPOSE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_PURPOSE_push(struct stack_st_X509_PURPOSE *sk, X509_PURPOSE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_PURPOSE_unshift(struct stack_st_X509_PURPOSE *sk, X509_PURPOSE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_PURPOSE *sk_X509_PURPOSE_pop(struct stack_st_X509_PURPOSE *sk) { return (X509_PURPOSE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_PURPOSE *sk_X509_PURPOSE_shift(struct stack_st_X509_PURPOSE *sk) { return (X509_PURPOSE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_PURPOSE_pop_free(struct stack_st_X509_PURPOSE *sk, sk_X509_PURPOSE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_PURPOSE_insert(struct stack_st_X509_PURPOSE *sk, X509_PURPOSE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_PURPOSE *sk_X509_PURPOSE_set(struct stack_st_X509_PURPOSE *sk, int idx, X509_PURPOSE *ptr) { return (X509_PURPOSE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_PURPOSE_find(struct stack_st_X509_PURPOSE *sk, X509_PURPOSE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_PURPOSE_find_ex(struct stack_st_X509_PURPOSE *sk, X509_PURPOSE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_PURPOSE_sort(struct stack_st_X509_PURPOSE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_PURPOSE_is_sorted(const struct stack_st_X509_PURPOSE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_PURPOSE * sk_X509_PURPOSE_dup(const struct stack_st_X509_PURPOSE *sk) { return (struct stack_st_X509_PURPOSE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_PURPOSE *sk_X509_PURPOSE_deep_copy(const struct stack_st_X509_PURPOSE *sk, sk_X509_PURPOSE_copyfunc copyfunc, sk_X509_PURPOSE_freefunc freefunc) { return (struct stack_st_X509_PURPOSE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_PURPOSE_compfunc sk_X509_PURPOSE_set_cmp_func(struct stack_st_X509_PURPOSE *sk, sk_X509_PURPOSE_compfunc compare) { return (sk_X509_PURPOSE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>BASIC_CONSTRAINTS *BASIC_CONSTRAINTS_new(void); void BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a); BASIC_CONSTRAINTS *d2i_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS **a, const unsigned char **in, long len); int i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **out); extern const ASN1_ITEM BASIC_CONSTRAINTS_it;
>
>SXNET *SXNET_new(void); void SXNET_free(SXNET *a); SXNET *d2i_SXNET(SXNET **a, const unsigned char **in, long len); int i2d_SXNET(SXNET *a, unsigned char **out); extern const ASN1_ITEM SXNET_it;
>SXNETID *SXNETID_new(void); void SXNETID_free(SXNETID *a); SXNETID *d2i_SXNETID(SXNETID **a, const unsigned char **in, long len); int i2d_SXNETID(SXNETID *a, unsigned char **out); extern const ASN1_ITEM SXNETID_it;
>
>int SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen);
>int SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user,
> int userlen);
>int SXNET_add_id_INTEGER(SXNET **psx, ASN1_INTEGER *izone, const char *user,
> int userlen);
>
>ASN1_OCTET_STRING *SXNET_get_id_asc(SXNET *sx, const char *zone);
>ASN1_OCTET_STRING *SXNET_get_id_ulong(SXNET *sx, unsigned long lzone);
>ASN1_OCTET_STRING *SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone);
>
>AUTHORITY_KEYID *AUTHORITY_KEYID_new(void); void AUTHORITY_KEYID_free(AUTHORITY_KEYID *a); AUTHORITY_KEYID *d2i_AUTHORITY_KEYID(AUTHORITY_KEYID **a, const unsigned char **in, long len); int i2d_AUTHORITY_KEYID(AUTHORITY_KEYID *a, unsigned char **out); extern const ASN1_ITEM AUTHORITY_KEYID_it;
>
>PKEY_USAGE_PERIOD *PKEY_USAGE_PERIOD_new(void); void PKEY_USAGE_PERIOD_free(PKEY_USAGE_PERIOD *a); PKEY_USAGE_PERIOD *d2i_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD **a, const unsigned char **in, long len); int i2d_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD *a, unsigned char **out); extern const ASN1_ITEM PKEY_USAGE_PERIOD_it;
>
>GENERAL_NAME *GENERAL_NAME_new(void); void GENERAL_NAME_free(GENERAL_NAME *a); GENERAL_NAME *d2i_GENERAL_NAME(GENERAL_NAME **a, const unsigned char **in, long len); int i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **out); extern const ASN1_ITEM GENERAL_NAME_it;
>GENERAL_NAME *GENERAL_NAME_dup(GENERAL_NAME *a);
>int GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b);
>
>ASN1_BIT_STRING *v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx,
> struct stack_st_CONF_VALUE *nval);
>struct stack_st_CONF_VALUE *i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method,
> ASN1_BIT_STRING *bits,
> struct stack_st_CONF_VALUE *extlist);
>char *i2s_ASN1_IA5STRING(X509V3_EXT_METHOD *method, ASN1_IA5STRING *ia5);
>ASN1_IA5STRING *s2i_ASN1_IA5STRING(X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx, const char *str);
>
>struct stack_st_CONF_VALUE *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method,
> GENERAL_NAME *gen,
> struct stack_st_CONF_VALUE *ret);
>int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen);
>
>GENERAL_NAMES *GENERAL_NAMES_new(void); void GENERAL_NAMES_free(GENERAL_NAMES *a); GENERAL_NAMES *d2i_GENERAL_NAMES(GENERAL_NAMES **a, const unsigned char **in, long len); int i2d_GENERAL_NAMES(GENERAL_NAMES *a, unsigned char **out); extern const ASN1_ITEM GENERAL_NAMES_it;
>
>struct stack_st_CONF_VALUE *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method,
> GENERAL_NAMES *gen,
> struct stack_st_CONF_VALUE *extlist);
>GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx, struct stack_st_CONF_VALUE *nval);
>
>OTHERNAME *OTHERNAME_new(void); void OTHERNAME_free(OTHERNAME *a); OTHERNAME *d2i_OTHERNAME(OTHERNAME **a, const unsigned char **in, long len); int i2d_OTHERNAME(OTHERNAME *a, unsigned char **out); extern const ASN1_ITEM OTHERNAME_it;
>EDIPARTYNAME *EDIPARTYNAME_new(void); void EDIPARTYNAME_free(EDIPARTYNAME *a); EDIPARTYNAME *d2i_EDIPARTYNAME(EDIPARTYNAME **a, const unsigned char **in, long len); int i2d_EDIPARTYNAME(EDIPARTYNAME *a, unsigned char **out); extern const ASN1_ITEM EDIPARTYNAME_it;
>int OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b);
>void GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value);
>void *GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype);
>int GENERAL_NAME_set0_othername(GENERAL_NAME *gen,
> ASN1_OBJECT *oid, ASN1_TYPE *value);
>int GENERAL_NAME_get0_otherName(GENERAL_NAME *gen,
> ASN1_OBJECT **poid, ASN1_TYPE **pvalue);
>
>char *i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
> const ASN1_OCTET_STRING *ia5);
>ASN1_OCTET_STRING *s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx, const char *str);
>
>EXTENDED_KEY_USAGE *EXTENDED_KEY_USAGE_new(void); void EXTENDED_KEY_USAGE_free(EXTENDED_KEY_USAGE *a); EXTENDED_KEY_USAGE *d2i_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE **a, const unsigned char **in, long len); int i2d_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE *a, unsigned char **out); extern const ASN1_ITEM EXTENDED_KEY_USAGE_it;
>int i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION *a);
>
>TLS_FEATURE *TLS_FEATURE_new(void); void TLS_FEATURE_free(TLS_FEATURE *a);
>
>CERTIFICATEPOLICIES *CERTIFICATEPOLICIES_new(void); void CERTIFICATEPOLICIES_free(CERTIFICATEPOLICIES *a); CERTIFICATEPOLICIES *d2i_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES **a, const unsigned char **in, long len); int i2d_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES *a, unsigned char **out); extern const ASN1_ITEM CERTIFICATEPOLICIES_it;
>POLICYINFO *POLICYINFO_new(void); void POLICYINFO_free(POLICYINFO *a); POLICYINFO *d2i_POLICYINFO(POLICYINFO **a, const unsigned char **in, long len); int i2d_POLICYINFO(POLICYINFO *a, unsigned char **out); extern const ASN1_ITEM POLICYINFO_it;
>POLICYQUALINFO *POLICYQUALINFO_new(void); void POLICYQUALINFO_free(POLICYQUALINFO *a); POLICYQUALINFO *d2i_POLICYQUALINFO(POLICYQUALINFO **a, const unsigned char **in, long len); int i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **out); extern const ASN1_ITEM POLICYQUALINFO_it;
>USERNOTICE *USERNOTICE_new(void); void USERNOTICE_free(USERNOTICE *a); USERNOTICE *d2i_USERNOTICE(USERNOTICE **a, const unsigned char **in, long len); int i2d_USERNOTICE(USERNOTICE *a, unsigned char **out); extern const ASN1_ITEM USERNOTICE_it;
>NOTICEREF *NOTICEREF_new(void); void NOTICEREF_free(NOTICEREF *a); NOTICEREF *d2i_NOTICEREF(NOTICEREF **a, const unsigned char **in, long len); int i2d_NOTICEREF(NOTICEREF *a, unsigned char **out); extern const ASN1_ITEM NOTICEREF_it;
>
>CRL_DIST_POINTS *CRL_DIST_POINTS_new(void); void CRL_DIST_POINTS_free(CRL_DIST_POINTS *a); CRL_DIST_POINTS *d2i_CRL_DIST_POINTS(CRL_DIST_POINTS **a, const unsigned char **in, long len); int i2d_CRL_DIST_POINTS(CRL_DIST_POINTS *a, unsigned char **out); extern const ASN1_ITEM CRL_DIST_POINTS_it;
>DIST_POINT *DIST_POINT_new(void); void DIST_POINT_free(DIST_POINT *a); DIST_POINT *d2i_DIST_POINT(DIST_POINT **a, const unsigned char **in, long len); int i2d_DIST_POINT(DIST_POINT *a, unsigned char **out); extern const ASN1_ITEM DIST_POINT_it;
>DIST_POINT_NAME *DIST_POINT_NAME_new(void); void DIST_POINT_NAME_free(DIST_POINT_NAME *a); DIST_POINT_NAME *d2i_DIST_POINT_NAME(DIST_POINT_NAME **a, const unsigned char **in, long len); int i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **out); extern const ASN1_ITEM DIST_POINT_NAME_it;
>ISSUING_DIST_POINT *ISSUING_DIST_POINT_new(void); void ISSUING_DIST_POINT_free(ISSUING_DIST_POINT *a); ISSUING_DIST_POINT *d2i_ISSUING_DIST_POINT(ISSUING_DIST_POINT **a, const unsigned char **in, long len); int i2d_ISSUING_DIST_POINT(ISSUING_DIST_POINT *a, unsigned char **out); extern const ASN1_ITEM ISSUING_DIST_POINT_it;
>
>int DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname);
>
>int NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc);
>int NAME_CONSTRAINTS_check_CN(X509 *x, NAME_CONSTRAINTS *nc);
>
>ACCESS_DESCRIPTION *ACCESS_DESCRIPTION_new(void); void ACCESS_DESCRIPTION_free(ACCESS_DESCRIPTION *a); ACCESS_DESCRIPTION *d2i_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION **a, const unsigned char **in, long len); int i2d_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION *a, unsigned char **out); extern const ASN1_ITEM ACCESS_DESCRIPTION_it;
>AUTHORITY_INFO_ACCESS *AUTHORITY_INFO_ACCESS_new(void); void AUTHORITY_INFO_ACCESS_free(AUTHORITY_INFO_ACCESS *a); AUTHORITY_INFO_ACCESS *d2i_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS **a, const unsigned char **in, long len); int i2d_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS *a, unsigned char **out); extern const ASN1_ITEM AUTHORITY_INFO_ACCESS_it;
>
>extern const ASN1_ITEM POLICY_MAPPING_it;
>POLICY_MAPPING *POLICY_MAPPING_new(void); void POLICY_MAPPING_free(POLICY_MAPPING *a);
>extern const ASN1_ITEM POLICY_MAPPINGS_it;
>
>extern const ASN1_ITEM GENERAL_SUBTREE_it;
>GENERAL_SUBTREE *GENERAL_SUBTREE_new(void); void GENERAL_SUBTREE_free(GENERAL_SUBTREE *a);
>
>extern const ASN1_ITEM NAME_CONSTRAINTS_it;
>NAME_CONSTRAINTS *NAME_CONSTRAINTS_new(void); void NAME_CONSTRAINTS_free(NAME_CONSTRAINTS *a);
>
>POLICY_CONSTRAINTS *POLICY_CONSTRAINTS_new(void); void POLICY_CONSTRAINTS_free(POLICY_CONSTRAINTS *a);
>extern const ASN1_ITEM POLICY_CONSTRAINTS_it;
>
>GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out,
> const X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx, int gen_type,
> const char *value, int is_nc);
>
>
>GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx, CONF_VALUE *cnf);
>GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out,
> const X509V3_EXT_METHOD *method,
> X509V3_CTX *ctx, CONF_VALUE *cnf,
> int is_nc);
>void X509V3_conf_free(CONF_VALUE *val);
>
>X509_EXTENSION *X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
> const char *value);
>X509_EXTENSION *X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name,
> const char *value);
>int X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section,
> struct stack_st_X509_EXTENSION **sk);
>int X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
> X509 *cert);
>int X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
> X509_REQ *req);
>int X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
> X509_CRL *crl);
>
>X509_EXTENSION *X509V3_EXT_conf_nid(struct lhash_st_CONF_VALUE *conf,
> X509V3_CTX *ctx, int ext_nid,
> const char *value);
>X509_EXTENSION *X509V3_EXT_conf(struct lhash_st_CONF_VALUE *conf, X509V3_CTX *ctx,
> const char *name, const char *value);
>int X509V3_EXT_add_conf(struct lhash_st_CONF_VALUE *conf, X509V3_CTX *ctx,
> const char *section, X509 *cert);
>int X509V3_EXT_REQ_add_conf(struct lhash_st_CONF_VALUE *conf, X509V3_CTX *ctx,
> const char *section, X509_REQ *req);
>int X509V3_EXT_CRL_add_conf(struct lhash_st_CONF_VALUE *conf, X509V3_CTX *ctx,
> const char *section, X509_CRL *crl);
>
>int X509V3_add_value_bool_nf(const char *name, int asn1_bool,
> struct stack_st_CONF_VALUE **extlist);
>int X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool);
>int X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint);
>void X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf);
>void X509V3_set_conf_lhash(X509V3_CTX *ctx, struct lhash_st_CONF_VALUE *lhash);
>
>
>char *X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section);
>struct stack_st_CONF_VALUE *X509V3_get_section(X509V3_CTX *ctx, const char *section);
>void X509V3_string_free(X509V3_CTX *ctx, char *str);
>void X509V3_section_free(X509V3_CTX *ctx, struct stack_st_CONF_VALUE *section);
>void X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subject,
> X509_REQ *req, X509_CRL *crl, int flags);
>
>int X509V3_add_value(const char *name, const char *value,
> struct stack_st_CONF_VALUE **extlist);
>int X509V3_add_value_uchar(const char *name, const unsigned char *value,
> struct stack_st_CONF_VALUE **extlist);
>int X509V3_add_value_bool(const char *name, int asn1_bool,
> struct stack_st_CONF_VALUE **extlist);
>int X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
> struct stack_st_CONF_VALUE **extlist);
>char *i2s_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const ASN1_INTEGER *aint);
>ASN1_INTEGER *s2i_ASN1_INTEGER(X509V3_EXT_METHOD *meth, const char *value);
>char *i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *meth, const ASN1_ENUMERATED *aint);
>char *i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *meth,
> const ASN1_ENUMERATED *aint);
>int X509V3_EXT_add(X509V3_EXT_METHOD *ext);
>int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist);
>int X509V3_EXT_add_alias(int nid_to, int nid_from);
>void X509V3_EXT_cleanup(void);
>
>const X509V3_EXT_METHOD *X509V3_EXT_get(X509_EXTENSION *ext);
>const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid);
>int X509V3_add_standard_extensions(void);
>struct stack_st_CONF_VALUE *X509V3_parse_list(const char *line);
>void *X509V3_EXT_d2i(X509_EXTENSION *ext);
>void *X509V3_get_d2i(const struct stack_st_X509_EXTENSION *x, int nid, int *crit,
> int *idx);
>
>X509_EXTENSION *X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc);
>int X509V3_add1_i2d(struct stack_st_X509_EXTENSION **x, int nid, void *value,
> int crit, unsigned long flags);
>
>
>
>
>
>
>
>void X509V3_EXT_val_prn(BIO *out, struct stack_st_CONF_VALUE *val, int indent,
> int ml);
>int X509V3_EXT_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
> int indent);
>
>int X509V3_EXT_print_fp(FILE *out, X509_EXTENSION *ext, int flag, int indent);
>
>int X509V3_extensions_print(BIO *out, const char *title,
> const struct stack_st_X509_EXTENSION *exts,
> unsigned long flag, int indent);
>
>int X509_check_ca(X509 *x);
>int X509_check_purpose(X509 *x, int id, int ca);
>int X509_supported_extension(X509_EXTENSION *ex);
>int X509_PURPOSE_set(int *p, int purpose);
>int X509_check_issued(X509 *issuer, X509 *subject);
>int X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid);
>void X509_set_proxy_flag(X509 *x);
>void X509_set_proxy_pathlen(X509 *x, long l);
>long X509_get_proxy_pathlen(X509 *x);
>
>uint32_t X509_get_extension_flags(X509 *x);
>uint32_t X509_get_key_usage(X509 *x);
>uint32_t X509_get_extended_key_usage(X509 *x);
>const ASN1_OCTET_STRING *X509_get0_subject_key_id(X509 *x);
>const ASN1_OCTET_STRING *X509_get0_authority_key_id(X509 *x);
>
>int X509_PURPOSE_get_count(void);
>X509_PURPOSE *X509_PURPOSE_get0(int idx);
>int X509_PURPOSE_get_by_sname(const char *sname);
>int X509_PURPOSE_get_by_id(int id);
>int X509_PURPOSE_add(int id, int trust, int flags,
> int (*ck) (const X509_PURPOSE *, const X509 *, int),
> const char *name, const char *sname, void *arg);
>char *X509_PURPOSE_get0_name(const X509_PURPOSE *xp);
>char *X509_PURPOSE_get0_sname(const X509_PURPOSE *xp);
>int X509_PURPOSE_get_trust(const X509_PURPOSE *xp);
>void X509_PURPOSE_cleanup(void);
>int X509_PURPOSE_get_id(const X509_PURPOSE *);
>
>struct stack_st_OPENSSL_STRING *X509_get1_email(X509 *x);
>struct stack_st_OPENSSL_STRING *X509_REQ_get1_email(X509_REQ *x);
>void X509_email_free(struct stack_st_OPENSSL_STRING *sk);
>struct stack_st_OPENSSL_STRING *X509_get1_ocsp(X509 *x);
># 703 "/usr/include/openssl/x509v3.h" 3 4
>int X509_check_host(X509 *x, const char *chk, size_t chklen,
> unsigned int flags, char **peername);
>int X509_check_email(X509 *x, const char *chk, size_t chklen,
> unsigned int flags);
>int X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
> unsigned int flags);
>int X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags);
>
>ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc);
>ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc);
>int X509V3_NAME_from_section(X509_NAME *nm, struct stack_st_CONF_VALUE *dn_sk,
> unsigned long chtype);
>
>void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent);
>struct stack_st_X509_POLICY_NODE; typedef int (*sk_X509_POLICY_NODE_compfunc)(const X509_POLICY_NODE * const *a, const X509_POLICY_NODE *const *b); typedef void (*sk_X509_POLICY_NODE_freefunc)(X509_POLICY_NODE *a); typedef X509_POLICY_NODE * (*sk_X509_POLICY_NODE_copyfunc)(const X509_POLICY_NODE *a); static inline int sk_X509_POLICY_NODE_num(const struct stack_st_X509_POLICY_NODE *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline X509_POLICY_NODE *sk_X509_POLICY_NODE_value(const struct stack_st_X509_POLICY_NODE *sk, int idx) { return (X509_POLICY_NODE *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_X509_POLICY_NODE *sk_X509_POLICY_NODE_new(sk_X509_POLICY_NODE_compfunc compare) { return (struct stack_st_X509_POLICY_NODE *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_X509_POLICY_NODE *sk_X509_POLICY_NODE_new_null(void) { return (struct stack_st_X509_POLICY_NODE *)OPENSSL_sk_new_null(); } static inline void sk_X509_POLICY_NODE_free(struct stack_st_X509_POLICY_NODE *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_X509_POLICY_NODE_zero(struct stack_st_X509_POLICY_NODE *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline X509_POLICY_NODE *sk_X509_POLICY_NODE_delete(struct stack_st_X509_POLICY_NODE *sk, int i) { return (X509_POLICY_NODE *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline X509_POLICY_NODE *sk_X509_POLICY_NODE_delete_ptr(struct stack_st_X509_POLICY_NODE *sk, X509_POLICY_NODE *ptr) { return (X509_POLICY_NODE *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_POLICY_NODE_push(struct stack_st_X509_POLICY_NODE *sk, X509_POLICY_NODE *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_POLICY_NODE_unshift(struct stack_st_X509_POLICY_NODE *sk, X509_POLICY_NODE *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline X509_POLICY_NODE *sk_X509_POLICY_NODE_pop(struct stack_st_X509_POLICY_NODE *sk) { return (X509_POLICY_NODE *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline X509_POLICY_NODE *sk_X509_POLICY_NODE_shift(struct stack_st_X509_POLICY_NODE *sk) { return (X509_POLICY_NODE *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_X509_POLICY_NODE_pop_free(struct stack_st_X509_POLICY_NODE *sk, sk_X509_POLICY_NODE_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_X509_POLICY_NODE_insert(struct stack_st_X509_POLICY_NODE *sk, X509_POLICY_NODE *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline X509_POLICY_NODE *sk_X509_POLICY_NODE_set(struct stack_st_X509_POLICY_NODE *sk, int idx, X509_POLICY_NODE *ptr) { return (X509_POLICY_NODE *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_X509_POLICY_NODE_find(struct stack_st_X509_POLICY_NODE *sk, X509_POLICY_NODE *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_X509_POLICY_NODE_find_ex(struct stack_st_X509_POLICY_NODE *sk, X509_POLICY_NODE *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_X509_POLICY_NODE_sort(struct stack_st_X509_POLICY_NODE *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_X509_POLICY_NODE_is_sorted(const struct stack_st_X509_POLICY_NODE *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_POLICY_NODE * sk_X509_POLICY_NODE_dup(const struct stack_st_X509_POLICY_NODE *sk) { return (struct stack_st_X509_POLICY_NODE *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_X509_POLICY_NODE *sk_X509_POLICY_NODE_deep_copy(const struct stack_st_X509_POLICY_NODE *sk, sk_X509_POLICY_NODE_copyfunc copyfunc, sk_X509_POLICY_NODE_freefunc freefunc) { return (struct stack_st_X509_POLICY_NODE *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_X509_POLICY_NODE_compfunc sk_X509_POLICY_NODE_set_cmp_func(struct stack_st_X509_POLICY_NODE *sk, sk_X509_POLICY_NODE_compfunc compare) { return (sk_X509_POLICY_NODE_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>typedef struct ASRange_st {
> ASN1_INTEGER *min, *max;
>} ASRange;
>
>
>
>
>typedef struct ASIdOrRange_st {
> int type;
> union {
> ASN1_INTEGER *id;
> ASRange *range;
> } u;
>} ASIdOrRange;
>
>typedef struct stack_st_ASIdOrRange ASIdOrRanges;
>struct stack_st_ASIdOrRange; typedef int (*sk_ASIdOrRange_compfunc)(const ASIdOrRange * const *a, const ASIdOrRange *const *b); typedef void (*sk_ASIdOrRange_freefunc)(ASIdOrRange *a); typedef ASIdOrRange * (*sk_ASIdOrRange_copyfunc)(const ASIdOrRange *a); static inline int sk_ASIdOrRange_num(const struct stack_st_ASIdOrRange *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline ASIdOrRange *sk_ASIdOrRange_value(const struct stack_st_ASIdOrRange *sk, int idx) { return (ASIdOrRange *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_ASIdOrRange *sk_ASIdOrRange_new(sk_ASIdOrRange_compfunc compare) { return (struct stack_st_ASIdOrRange *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_ASIdOrRange *sk_ASIdOrRange_new_null(void) { return (struct stack_st_ASIdOrRange *)OPENSSL_sk_new_null(); } static inline void sk_ASIdOrRange_free(struct stack_st_ASIdOrRange *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_ASIdOrRange_zero(struct stack_st_ASIdOrRange *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline ASIdOrRange *sk_ASIdOrRange_delete(struct stack_st_ASIdOrRange *sk, int i) { return (ASIdOrRange *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline ASIdOrRange *sk_ASIdOrRange_delete_ptr(struct stack_st_ASIdOrRange *sk, ASIdOrRange *ptr) { return (ASIdOrRange *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASIdOrRange_push(struct stack_st_ASIdOrRange *sk, ASIdOrRange *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASIdOrRange_unshift(struct stack_st_ASIdOrRange *sk, ASIdOrRange *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline ASIdOrRange *sk_ASIdOrRange_pop(struct stack_st_ASIdOrRange *sk) { return (ASIdOrRange *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline ASIdOrRange *sk_ASIdOrRange_shift(struct stack_st_ASIdOrRange *sk) { return (ASIdOrRange *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_ASIdOrRange_pop_free(struct stack_st_ASIdOrRange *sk, sk_ASIdOrRange_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_ASIdOrRange_insert(struct stack_st_ASIdOrRange *sk, ASIdOrRange *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline ASIdOrRange *sk_ASIdOrRange_set(struct stack_st_ASIdOrRange *sk, int idx, ASIdOrRange *ptr) { return (ASIdOrRange *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_ASIdOrRange_find(struct stack_st_ASIdOrRange *sk, ASIdOrRange *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_ASIdOrRange_find_ex(struct stack_st_ASIdOrRange *sk, ASIdOrRange *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_ASIdOrRange_sort(struct stack_st_ASIdOrRange *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_ASIdOrRange_is_sorted(const struct stack_st_ASIdOrRange *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASIdOrRange * sk_ASIdOrRange_dup(const struct stack_st_ASIdOrRange *sk) { return (struct stack_st_ASIdOrRange *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_ASIdOrRange *sk_ASIdOrRange_deep_copy(const struct stack_st_ASIdOrRange *sk, sk_ASIdOrRange_copyfunc copyfunc, sk_ASIdOrRange_freefunc freefunc) { return (struct stack_st_ASIdOrRange *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_ASIdOrRange_compfunc sk_ASIdOrRange_set_cmp_func(struct stack_st_ASIdOrRange *sk, sk_ASIdOrRange_compfunc compare) { return (sk_ASIdOrRange_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>
>typedef struct ASIdentifierChoice_st {
> int type;
> union {
> ASN1_NULL *inherit;
> ASIdOrRanges *asIdsOrRanges;
> } u;
>} ASIdentifierChoice;
>
>typedef struct ASIdentifiers_st {
> ASIdentifierChoice *asnum, *rdi;
>} ASIdentifiers;
>
>ASRange *ASRange_new(void); void ASRange_free(ASRange *a); ASRange *d2i_ASRange(ASRange **a, const unsigned char **in, long len); int i2d_ASRange(ASRange *a, unsigned char **out); extern const ASN1_ITEM ASRange_it;
>ASIdOrRange *ASIdOrRange_new(void); void ASIdOrRange_free(ASIdOrRange *a); ASIdOrRange *d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len); int i2d_ASIdOrRange(ASIdOrRange *a, unsigned char **out); extern const ASN1_ITEM ASIdOrRange_it;
>ASIdentifierChoice *ASIdentifierChoice_new(void); void ASIdentifierChoice_free(ASIdentifierChoice *a); ASIdentifierChoice *d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in, long len); int i2d_ASIdentifierChoice(ASIdentifierChoice *a, unsigned char **out); extern const ASN1_ITEM ASIdentifierChoice_it;
>ASIdentifiers *ASIdentifiers_new(void); void ASIdentifiers_free(ASIdentifiers *a); ASIdentifiers *d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len); int i2d_ASIdentifiers(ASIdentifiers *a, unsigned char **out); extern const ASN1_ITEM ASIdentifiers_it;
>
>typedef struct IPAddressRange_st {
> ASN1_BIT_STRING *min, *max;
>} IPAddressRange;
>
>
>
>
>typedef struct IPAddressOrRange_st {
> int type;
> union {
> ASN1_BIT_STRING *addressPrefix;
> IPAddressRange *addressRange;
> } u;
>} IPAddressOrRange;
>
>typedef struct stack_st_IPAddressOrRange IPAddressOrRanges;
>struct stack_st_IPAddressOrRange; typedef int (*sk_IPAddressOrRange_compfunc)(const IPAddressOrRange * const *a, const IPAddressOrRange *const *b); typedef void (*sk_IPAddressOrRange_freefunc)(IPAddressOrRange *a); typedef IPAddressOrRange * (*sk_IPAddressOrRange_copyfunc)(const IPAddressOrRange *a); static inline int sk_IPAddressOrRange_num(const struct stack_st_IPAddressOrRange *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline IPAddressOrRange *sk_IPAddressOrRange_value(const struct stack_st_IPAddressOrRange *sk, int idx) { return (IPAddressOrRange *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_IPAddressOrRange *sk_IPAddressOrRange_new(sk_IPAddressOrRange_compfunc compare) { return (struct stack_st_IPAddressOrRange *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_IPAddressOrRange *sk_IPAddressOrRange_new_null(void) { return (struct stack_st_IPAddressOrRange *)OPENSSL_sk_new_null(); } static inline void sk_IPAddressOrRange_free(struct stack_st_IPAddressOrRange *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_IPAddressOrRange_zero(struct stack_st_IPAddressOrRange *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline IPAddressOrRange *sk_IPAddressOrRange_delete(struct stack_st_IPAddressOrRange *sk, int i) { return (IPAddressOrRange *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline IPAddressOrRange *sk_IPAddressOrRange_delete_ptr(struct stack_st_IPAddressOrRange *sk, IPAddressOrRange *ptr) { return (IPAddressOrRange *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_IPAddressOrRange_push(struct stack_st_IPAddressOrRange *sk, IPAddressOrRange *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_IPAddressOrRange_unshift(struct stack_st_IPAddressOrRange *sk, IPAddressOrRange *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline IPAddressOrRange *sk_IPAddressOrRange_pop(struct stack_st_IPAddressOrRange *sk) { return (IPAddressOrRange *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline IPAddressOrRange *sk_IPAddressOrRange_shift(struct stack_st_IPAddressOrRange *sk) { return (IPAddressOrRange *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_IPAddressOrRange_pop_free(struct stack_st_IPAddressOrRange *sk, sk_IPAddressOrRange_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_IPAddressOrRange_insert(struct stack_st_IPAddressOrRange *sk, IPAddressOrRange *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline IPAddressOrRange *sk_IPAddressOrRange_set(struct stack_st_IPAddressOrRange *sk, int idx, IPAddressOrRange *ptr) { return (IPAddressOrRange *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_IPAddressOrRange_find(struct stack_st_IPAddressOrRange *sk, IPAddressOrRange *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_IPAddressOrRange_find_ex(struct stack_st_IPAddressOrRange *sk, IPAddressOrRange *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_IPAddressOrRange_sort(struct stack_st_IPAddressOrRange *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_IPAddressOrRange_is_sorted(const struct stack_st_IPAddressOrRange *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_IPAddressOrRange * sk_IPAddressOrRange_dup(const struct stack_st_IPAddressOrRange *sk) { return (struct stack_st_IPAddressOrRange *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_IPAddressOrRange *sk_IPAddressOrRange_deep_copy(const struct stack_st_IPAddressOrRange *sk, sk_IPAddressOrRange_copyfunc copyfunc, sk_IPAddressOrRange_freefunc freefunc) { return (struct stack_st_IPAddressOrRange *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_IPAddressOrRange_compfunc sk_IPAddressOrRange_set_cmp_func(struct stack_st_IPAddressOrRange *sk, sk_IPAddressOrRange_compfunc compare) { return (sk_IPAddressOrRange_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>
>
>
>typedef struct IPAddressChoice_st {
> int type;
> union {
> ASN1_NULL *inherit;
> IPAddressOrRanges *addressesOrRanges;
> } u;
>} IPAddressChoice;
>
>typedef struct IPAddressFamily_st {
> ASN1_OCTET_STRING *addressFamily;
> IPAddressChoice *ipAddressChoice;
>} IPAddressFamily;
>
>typedef struct stack_st_IPAddressFamily IPAddrBlocks;
>struct stack_st_IPAddressFamily; typedef int (*sk_IPAddressFamily_compfunc)(const IPAddressFamily * const *a, const IPAddressFamily *const *b); typedef void (*sk_IPAddressFamily_freefunc)(IPAddressFamily *a); typedef IPAddressFamily * (*sk_IPAddressFamily_copyfunc)(const IPAddressFamily *a); static inline int sk_IPAddressFamily_num(const struct stack_st_IPAddressFamily *sk) { return OPENSSL_sk_num((const OPENSSL_STACK *)sk); } static inline IPAddressFamily *sk_IPAddressFamily_value(const struct stack_st_IPAddressFamily *sk, int idx) { return (IPAddressFamily *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); } static inline struct stack_st_IPAddressFamily *sk_IPAddressFamily_new(sk_IPAddressFamily_compfunc compare) { return (struct stack_st_IPAddressFamily *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); } static inline struct stack_st_IPAddressFamily *sk_IPAddressFamily_new_null(void) { return (struct stack_st_IPAddressFamily *)OPENSSL_sk_new_null(); } static inline void sk_IPAddressFamily_free(struct stack_st_IPAddressFamily *sk) { OPENSSL_sk_free((OPENSSL_STACK *)sk); } static inline void sk_IPAddressFamily_zero(struct stack_st_IPAddressFamily *sk) { OPENSSL_sk_zero((OPENSSL_STACK *)sk); } static inline IPAddressFamily *sk_IPAddressFamily_delete(struct stack_st_IPAddressFamily *sk, int i) { return (IPAddressFamily *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); } static inline IPAddressFamily *sk_IPAddressFamily_delete_ptr(struct stack_st_IPAddressFamily *sk, IPAddressFamily *ptr) { return (IPAddressFamily *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_IPAddressFamily_push(struct stack_st_IPAddressFamily *sk, IPAddressFamily *ptr) { return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_IPAddressFamily_unshift(struct stack_st_IPAddressFamily *sk, IPAddressFamily *ptr) { return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); } static inline IPAddressFamily *sk_IPAddressFamily_pop(struct stack_st_IPAddressFamily *sk) { return (IPAddressFamily *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); } static inline IPAddressFamily *sk_IPAddressFamily_shift(struct stack_st_IPAddressFamily *sk) { return (IPAddressFamily *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); } static inline void sk_IPAddressFamily_pop_free(struct stack_st_IPAddressFamily *sk, sk_IPAddressFamily_freefunc freefunc) { OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); } static inline int sk_IPAddressFamily_insert(struct stack_st_IPAddressFamily *sk, IPAddressFamily *ptr, int idx) { return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); } static inline IPAddressFamily *sk_IPAddressFamily_set(struct stack_st_IPAddressFamily *sk, int idx, IPAddressFamily *ptr) { return (IPAddressFamily *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); } static inline int sk_IPAddressFamily_find(struct stack_st_IPAddressFamily *sk, IPAddressFamily *ptr) { return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); } static inline int sk_IPAddressFamily_find_ex(struct stack_st_IPAddressFamily *sk, IPAddressFamily *ptr) { return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); } static inline void sk_IPAddressFamily_sort(struct stack_st_IPAddressFamily *sk) { OPENSSL_sk_sort((OPENSSL_STACK *)sk); } static inline int sk_IPAddressFamily_is_sorted(const struct stack_st_IPAddressFamily *sk) { return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); } static inline struct stack_st_IPAddressFamily * sk_IPAddressFamily_dup(const struct stack_st_IPAddressFamily *sk) { return (struct stack_st_IPAddressFamily *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); } static inline struct stack_st_IPAddressFamily *sk_IPAddressFamily_deep_copy(const struct stack_st_IPAddressFamily *sk, sk_IPAddressFamily_copyfunc copyfunc, sk_IPAddressFamily_freefunc freefunc) { return (struct stack_st_IPAddressFamily *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, (OPENSSL_sk_copyfunc)copyfunc, (OPENSSL_sk_freefunc)freefunc); } static inline sk_IPAddressFamily_compfunc sk_IPAddressFamily_set_cmp_func(struct stack_st_IPAddressFamily *sk, sk_IPAddressFamily_compfunc compare) { return (sk_IPAddressFamily_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); }
>
>IPAddressRange *IPAddressRange_new(void); void IPAddressRange_free(IPAddressRange *a); IPAddressRange *d2i_IPAddressRange(IPAddressRange **a, const unsigned char **in, long len); int i2d_IPAddressRange(IPAddressRange *a, unsigned char **out); extern const ASN1_ITEM IPAddressRange_it;
>IPAddressOrRange *IPAddressOrRange_new(void); void IPAddressOrRange_free(IPAddressOrRange *a); IPAddressOrRange *d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len); int i2d_IPAddressOrRange(IPAddressOrRange *a, unsigned char **out); extern const ASN1_ITEM IPAddressOrRange_it;
>IPAddressChoice *IPAddressChoice_new(void); void IPAddressChoice_free(IPAddressChoice *a); IPAddressChoice *d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len); int i2d_IPAddressChoice(IPAddressChoice *a, unsigned char **out); extern const ASN1_ITEM IPAddressChoice_it;
>IPAddressFamily *IPAddressFamily_new(void); void IPAddressFamily_free(IPAddressFamily *a); IPAddressFamily *d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len); int i2d_IPAddressFamily(IPAddressFamily *a, unsigned char **out); extern const ASN1_ITEM IPAddressFamily_it;
># 820 "/usr/include/openssl/x509v3.h" 3 4
>int X509v3_asid_add_inherit(ASIdentifiers *asid, int which);
>int X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which,
> ASN1_INTEGER *min, ASN1_INTEGER *max);
>int X509v3_addr_add_inherit(IPAddrBlocks *addr,
> const unsigned afi, const unsigned *safi);
>int X509v3_addr_add_prefix(IPAddrBlocks *addr,
> const unsigned afi, const unsigned *safi,
> unsigned char *a, const int prefixlen);
>int X509v3_addr_add_range(IPAddrBlocks *addr,
> const unsigned afi, const unsigned *safi,
> unsigned char *min, unsigned char *max);
>unsigned X509v3_addr_get_afi(const IPAddressFamily *f);
>int X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi,
> unsigned char *min, unsigned char *max,
> const int length);
>
>
>
>
>int X509v3_asid_is_canonical(ASIdentifiers *asid);
>int X509v3_addr_is_canonical(IPAddrBlocks *addr);
>int X509v3_asid_canonize(ASIdentifiers *asid);
>int X509v3_addr_canonize(IPAddrBlocks *addr);
>
>
>
>
>int X509v3_asid_inherits(ASIdentifiers *asid);
>int X509v3_addr_inherits(IPAddrBlocks *addr);
>int X509v3_asid_subset(ASIdentifiers *a, ASIdentifiers *b);
>int X509v3_addr_subset(IPAddrBlocks *a, IPAddrBlocks *b);
>
>
>
>
>int X509v3_asid_validate_path(X509_STORE_CTX *);
>int X509v3_addr_validate_path(X509_STORE_CTX *);
>int X509v3_asid_validate_resource_set(struct stack_st_X509 *chain,
> ASIdentifiers *ext,
> int allow_inheritance);
>int X509v3_addr_validate_resource_set(struct stack_st_X509 *chain,
> IPAddrBlocks *ext, int allow_inheritance);
># 871 "/usr/include/openssl/x509v3.h" 3 4
>int ERR_load_X509V3_strings(void);
># 1006 "/usr/include/openssl/x509v3.h" 3 4
>}
># 29 "/usr/include/boost/asio/ssl/detail/openssl_types.hpp" 2 3 4
># 20 "/usr/include/boost/asio/ssl/context_base.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ssl/context_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>
>
>class context_base
>{
>public:
>
> enum method
> {
>
> sslv2,
>
>
> sslv2_client,
>
>
> sslv2_server,
>
>
> sslv3,
>
>
> sslv3_client,
>
>
> sslv3_server,
>
>
> tlsv1,
>
>
> tlsv1_client,
>
>
> tlsv1_server,
>
>
> sslv23,
>
>
> sslv23_client,
>
>
> sslv23_server,
>
>
> tlsv11,
>
>
> tlsv11_client,
>
>
> tlsv11_server,
>
>
> tlsv12,
>
>
> tlsv12_client,
>
>
> tlsv12_server,
>
>
> tls,
>
>
> tls_client,
>
>
> tls_server
> };
>
>
> typedef long options;
># 127 "/usr/include/boost/asio/ssl/context_base.hpp" 3 4
> static const long default_workarounds = (0x80000000U| 0x00000800U| 0x00000004U| 0x00000010U| 0x00000040U);
> static const long single_dh_use = 0x0;
> static const long no_sslv2 = 0x0;
> static const long no_sslv3 = 0x02000000U;
> static const long no_tlsv1 = 0x04000000U;
>
> static const long no_tlsv1_1 = 0x10000000U;
>
>
>
>
> static const long no_tlsv1_2 = 0x08000000U;
>
>
>
>
> static const long no_compression = 0x00020000U;
>
>
>
>
>
>
> enum file_format
> {
>
> asn1,
>
>
> pem
> };
>
>
>
>
>
> typedef int verify_mode;
> static const int verify_none = 0x00;
> static const int verify_peer = 0x01;
> static const int verify_fail_if_no_peer_cert = 0x02
> ;
> static const int verify_client_once = 0x04;
>
>
>
> enum password_purpose
> {
>
> for_reading,
>
>
> for_writing
> };
>
>protected:
>
> ~context_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 193 "/usr/include/boost/asio/ssl/context_base.hpp" 2 3 4
># 24 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 1 3 4
># 19 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 20 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 2 3 4
>
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class openssl_init_base
> : private noncopyable
>{
>protected:
>
> class do_init;
>
>
>
>
>
>
> inline static boost::asio::detail::shared_ptr<do_init> instance();
># 52 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 3 4
>};
>
>template <bool Do_Init = true>
>class openssl_init : private openssl_init_base
>{
>public:
>
> openssl_init()
> : ref_(instance())
> {
> using namespace std;
>
>
> openssl_init* tmp = &instance_;
> memmove(&tmp, &tmp, sizeof(openssl_init*));
> }
>
>
> ~openssl_init()
> {
> }
>
>
>
>
>
>
>
>private:
>
> static openssl_init instance_;
>
>
>
> boost::asio::detail::shared_ptr<do_init> ref_;
>};
>
>template <bool Do_Init>
>openssl_init<Do_Init> openssl_init<Do_Init>::instance_;
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 98 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 1 3 4
># 24 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 3 4
># 1 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 1 3 4
># 25 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class openssl_init_base::do_init
>{
>public:
> do_init()
> {
># 58 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 3 4
> }
>
> ~do_init()
> {
># 88 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 3 4
> ::CONF_modules_unload(1);
>
>
>
>
>
>
> }
># 106 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 3 4
>private:
># 140 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 3 4
>};
>
>boost::asio::detail::shared_ptr<openssl_init_base::do_init>
>openssl_init_base::instance()
>{
> static boost::asio::detail::shared_ptr<do_init> init(new do_init);
> return init;
>}
># 158 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 3 4
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 164 "/usr/include/boost/asio/ssl/detail/impl/openssl_init.ipp" 2 3 4
># 101 "/usr/include/boost/asio/ssl/detail/openssl_init.hpp" 2 3 4
># 26 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/detail/password_callback.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ssl/detail/password_callback.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/ssl/detail/password_callback.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class password_callback_base
>{
>public:
> virtual ~password_callback_base()
> {
> }
>
> virtual std::string call(std::size_t size,
> context_base::password_purpose purpose) = 0;
>};
>
>template <typename PasswordCallback>
>class password_callback : public password_callback_base
>{
>public:
> explicit password_callback(PasswordCallback callback)
> : callback_(callback)
> {
> }
>
> virtual std::string call(std::size_t size,
> context_base::password_purpose purpose)
> {
> return callback_(size, purpose);
> }
>
>private:
> PasswordCallback callback_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 67 "/usr/include/boost/asio/ssl/detail/password_callback.hpp" 2 3 4
># 27 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/detail/verify_callback.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ssl/detail/verify_callback.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/verify_context.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ssl/verify_context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/ssl/verify_context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>
>
>
>
>
>class verify_context
> : private noncopyable
>{
>public:
>
> typedef X509_STORE_CTX* native_handle_type;
>
>
> explicit verify_context(native_handle_type handle)
> : handle_(handle)
> {
> }
>
>
>
>
>
>
>
> native_handle_type native_handle()
> {
> return handle_;
> }
>
>private:
>
> native_handle_type handle_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 68 "/usr/include/boost/asio/ssl/verify_context.hpp" 2 3 4
># 21 "/usr/include/boost/asio/ssl/detail/verify_callback.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ssl/detail/verify_callback.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class verify_callback_base
>{
>public:
> virtual ~verify_callback_base()
> {
> }
>
> virtual bool call(bool preverified, verify_context& ctx) = 0;
>};
>
>template <typename VerifyCallback>
>class verify_callback : public verify_callback_base
>{
>public:
> explicit verify_callback(VerifyCallback callback)
> : callback_(callback)
> {
> }
>
> virtual bool call(bool preverified, verify_context& ctx)
> {
> return callback_(preverified, ctx);
> }
>
>private:
> VerifyCallback callback_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 63 "/usr/include/boost/asio/ssl/detail/verify_callback.hpp" 2 3 4
># 28 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/verify_mode.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ssl/verify_mode.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 22 "/usr/include/boost/asio/ssl/verify_mode.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
># 36 "/usr/include/boost/asio/ssl/verify_mode.hpp" 3 4
>typedef int verify_mode;
># 53 "/usr/include/boost/asio/ssl/verify_mode.hpp" 3 4
>const int verify_none = 0x00;
>const int verify_peer = 0x01;
>const int verify_fail_if_no_peer_cert = 0x02;
>const int verify_client_once = 0x04;
>
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 64 "/usr/include/boost/asio/ssl/verify_mode.hpp" 2 3 4
># 29 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 31 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>class context
> : public context_base,
> private noncopyable
>{
>public:
>
> typedef SSL_CTX* native_handle_type;
>
>
> inline explicit context(method m);
># 59 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline context(context&& other);
># 72 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline context& operator=(context&& other);
>
>
>
> inline ~context();
>
>
>
>
>
>
>
> inline native_handle_type native_handle();
># 98 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void clear_options(options o);
># 112 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code clear_options(options o,
> boost::system::error_code& ec);
># 127 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void set_options(options o);
># 141 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code set_options(options o,
> boost::system::error_code& ec);
># 156 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void set_verify_mode(verify_mode v);
># 170 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code set_verify_mode(
> verify_mode v, boost::system::error_code& ec);
># 185 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void set_verify_depth(int depth);
># 199 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code set_verify_depth(
> int depth, boost::system::error_code& ec);
># 220 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> template <typename VerifyCallback>
> void set_verify_callback(VerifyCallback callback);
># 241 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> template <typename VerifyCallback>
> boost::system::error_code set_verify_callback(VerifyCallback callback,
> boost::system::error_code& ec);
># 257 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void load_verify_file(const std::string& filename);
># 271 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code load_verify_file(
> const std::string& filename, boost::system::error_code& ec);
># 286 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void add_certificate_authority(const const_buffer& ca);
># 300 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code add_certificate_authority(
> const const_buffer& ca, boost::system::error_code& ec);
># 314 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void set_default_verify_paths();
># 327 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code set_default_verify_paths(
> boost::system::error_code& ec);
># 344 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void add_verify_path(const std::string& path);
># 360 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code add_verify_path(
> const std::string& path, boost::system::error_code& ec);
># 375 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_certificate(
> const const_buffer& certificate, file_format format);
># 390 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_certificate(
> const const_buffer& certificate, file_format format,
> boost::system::error_code& ec);
># 406 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_certificate_file(
> const std::string& filename, file_format format);
># 421 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_certificate_file(
> const std::string& filename, file_format format,
> boost::system::error_code& ec);
># 437 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_certificate_chain(const const_buffer& chain);
># 451 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_certificate_chain(
> const const_buffer& chain, boost::system::error_code& ec);
># 466 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_certificate_chain_file(const std::string& filename);
># 480 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_certificate_chain_file(
> const std::string& filename, boost::system::error_code& ec);
># 495 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_private_key(
> const const_buffer& private_key, file_format format);
># 510 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_private_key(
> const const_buffer& private_key, file_format format,
> boost::system::error_code& ec);
># 526 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_private_key_file(
> const std::string& filename, file_format format);
># 541 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_private_key_file(
> const std::string& filename, file_format format,
> boost::system::error_code& ec);
># 558 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_rsa_private_key(
> const const_buffer& private_key, file_format format);
># 574 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_rsa_private_key(
> const const_buffer& private_key, file_format format,
> boost::system::error_code& ec);
># 591 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_rsa_private_key_file(
> const std::string& filename, file_format format);
># 607 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_rsa_private_key_file(
> const std::string& filename, file_format format,
> boost::system::error_code& ec);
># 624 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_tmp_dh(const const_buffer& dh);
># 639 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_tmp_dh(
> const const_buffer& dh, boost::system::error_code& ec);
># 654 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline void use_tmp_dh_file(const std::string& filename);
># 668 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> inline boost::system::error_code use_tmp_dh_file(
> const std::string& filename, boost::system::error_code& ec);
># 688 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> template <typename PasswordCallback>
> void set_password_callback(PasswordCallback callback);
># 708 "/usr/include/boost/asio/ssl/context.hpp" 3 4
> template <typename PasswordCallback>
> boost::system::error_code set_password_callback(PasswordCallback callback,
> boost::system::error_code& ec);
>
>private:
> struct bio_cleanup;
> struct x509_cleanup;
> struct evp_pkey_cleanup;
> struct rsa_cleanup;
> struct dh_cleanup;
>
>
> inline boost::system::error_code do_set_verify_callback(
> detail::verify_callback_base* callback, boost::system::error_code& ec);
>
>
> inline static int verify_callback_function(
> int preverified, X509_STORE_CTX* ctx);
>
>
> inline boost::system::error_code do_set_password_callback(
> detail::password_callback_base* callback, boost::system::error_code& ec);
>
>
> inline static int password_callback_function(
> char* buf, int size, int purpose, void* data);
>
>
> inline boost::system::error_code do_use_tmp_dh(
> BIO* bio, boost::system::error_code& ec);
>
>
> inline BIO* make_buffer_bio(const const_buffer& b);
>
>
> native_handle_type handle_;
>
>
> boost::asio::ssl::detail::openssl_init<> init_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 754 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ssl/impl/context.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ssl/impl/context.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/ssl/impl/context.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>template <typename VerifyCallback>
>void context::set_verify_callback(VerifyCallback callback)
>{
> boost::system::error_code ec;
> this->set_verify_callback(callback, ec);
> boost::asio::detail::throw_error(ec, "set_verify_callback");
>}
>
>template <typename VerifyCallback>
>boost::system::error_code context::set_verify_callback(
> VerifyCallback callback, boost::system::error_code& ec)
>{
> do_set_verify_callback(
> new detail::verify_callback<VerifyCallback>(callback), ec);
> return ec;
>}
>
>template <typename PasswordCallback>
>void context::set_password_callback(PasswordCallback callback)
>{
> boost::system::error_code ec;
> this->set_password_callback(callback, ec);
> boost::asio::detail::throw_error(ec, "set_password_callback");
>}
>
>template <typename PasswordCallback>
>boost::system::error_code context::set_password_callback(
> PasswordCallback callback, boost::system::error_code& ec)
>{
> do_set_password_callback(
> new detail::password_callback<PasswordCallback>(callback), ec);
> return ec;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 68 "/usr/include/boost/asio/ssl/impl/context.hpp" 2 3 4
># 756 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ssl/impl/context.ipp" 1 3 4
># 21 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 22 "/usr/include/boost/asio/ssl/impl/context.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ssl/context.hpp" 1 3 4
># 25 "/usr/include/boost/asio/ssl/impl/context.ipp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/error.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ssl/error.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ssl/error.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace error {
>
>enum ssl_errors
>{
>
>};
>
>extern inline
>const boost::system::error_category& get_ssl_category();
>
>static const boost::system::error_category&
> ssl_category __attribute__((__unused__))
> = boost::asio::error::get_ssl_category();
>
>}
>namespace ssl {
>namespace error {
>
>enum stream_errors
>{
>
>
>
>
>
>
> stream_truncated = 1
>
>};
>
>extern inline
>const boost::system::error_category& get_stream_category();
>
>static const boost::system::error_category&
> stream_category __attribute__((__unused__))
> = boost::asio::ssl::error::get_stream_category();
>
>}
>}
>}
>}
>
>namespace boost {
>namespace system {
>
>template<> struct is_error_code_enum<boost::asio::error::ssl_errors>
>{
> static const bool value = true;
>};
>
>template<> struct is_error_code_enum<boost::asio::ssl::error::stream_errors>
>{
> static const bool value = true;
>};
>
>}
>}
>
>namespace boost {
>namespace asio {
>namespace error {
>
>inline boost::system::error_code make_error_code(ssl_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_ssl_category());
>}
>
>}
>namespace ssl {
>namespace error {
>
>inline boost::system::error_code make_error_code(stream_errors e)
>{
> return boost::system::error_code(
> static_cast<int>(e), get_stream_category());
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 110 "/usr/include/boost/asio/ssl/error.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ssl/impl/error.ipp" 1 3 4
># 19 "/usr/include/boost/asio/ssl/impl/error.ipp" 3 4
># 1 "/usr/include/boost/asio/ssl/error.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ssl/impl/error.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ssl/impl/error.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace error {
>namespace detail {
>
>class ssl_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.ssl";
> }
>
> std::string message(int value) const
> {
> const char* s = ::ERR_reason_error_string(value);
> return s ? s : "asio.ssl error";
> }
>};
>
>}
>
>const boost::system::error_category& get_ssl_category()
>{
> static detail::ssl_category instance;
> return instance;
>}
>
>}
>namespace ssl {
>namespace error {
># 65 "/usr/include/boost/asio/ssl/impl/error.ipp" 3 4
>namespace detail {
>
>class stream_category : public boost::system::error_category
>{
>public:
> const char* name() const noexcept
> {
> return "asio.ssl.stream";
> }
>
> std::string message(int value) const
> {
> switch (value)
> {
> case stream_truncated: return "stream truncated";
> default: return "asio.ssl.stream error";
> }
> }
>};
>
>}
>
>const boost::system::error_category& get_stream_category()
>{
> static detail::stream_category instance;
> return instance;
>}
>
>
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 101 "/usr/include/boost/asio/ssl/impl/error.ipp" 2 3 4
># 113 "/usr/include/boost/asio/ssl/error.hpp" 2 3 4
># 26 "/usr/include/boost/asio/ssl/impl/context.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/ssl/impl/context.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>struct context::bio_cleanup
>{
> BIO* p;
> ~bio_cleanup() { if (p) ::BIO_free(p); }
>};
>
>struct context::x509_cleanup
>{
> X509* p;
> ~x509_cleanup() { if (p) ::X509_free(p); }
>};
>
>struct context::evp_pkey_cleanup
>{
> EVP_PKEY* p;
> ~evp_pkey_cleanup() { if (p) ::EVP_PKEY_free(p); }
>};
>
>struct context::rsa_cleanup
>{
> RSA* p;
> ~rsa_cleanup() { if (p) ::RSA_free(p); }
>};
>
>struct context::dh_cleanup
>{
> DH* p;
> ~dh_cleanup() { if (p) ::DH_free(p); }
>};
>
>context::context(context::method m)
> : handle_(0)
>{
> ::ERR_clear_error();
>
> switch (m)
> {
>
>
> case context::sslv2:
> case context::sslv2_client:
> case context::sslv2_server:
> boost::asio::detail::throw_error(
> boost::asio::error::invalid_argument, "context");
> break;
># 92 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> case context::sslv3:
> handle_ = ::SSL_CTX_new(::TLS_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0300, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0300, __null);
> }
> break;
> case context::sslv3_client:
> handle_ = ::SSL_CTX_new(::TLS_client_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0300, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0300, __null);
> }
> break;
> case context::sslv3_server:
> handle_ = ::SSL_CTX_new(::TLS_server_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0300, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0300, __null);
> }
> break;
># 137 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> case context::tlsv1:
> handle_ = ::SSL_CTX_new(::TLS_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0301, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0301, __null);
> }
> break;
> case context::tlsv1_client:
> handle_ = ::SSL_CTX_new(::TLS_client_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0301, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0301, __null);
> }
> break;
> case context::tlsv1_server:
> handle_ = ::SSL_CTX_new(::TLS_server_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0301, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0301, __null);
> }
> break;
># 175 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> case context::tlsv11:
> handle_ = ::SSL_CTX_new(::TLS_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0302, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0302, __null);
> }
> break;
> case context::tlsv11_client:
> handle_ = ::SSL_CTX_new(::TLS_client_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0302, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0302, __null);
> }
> break;
> case context::tlsv11_server:
> handle_ = ::SSL_CTX_new(::TLS_server_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0302, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0302, __null);
> }
> break;
># 220 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> case context::tlsv12:
> handle_ = ::SSL_CTX_new(::TLS_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0303, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0303, __null);
> }
> break;
> case context::tlsv12_client:
> handle_ = ::SSL_CTX_new(::TLS_client_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0303, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0303, __null);
> }
> break;
> case context::tlsv12_server:
> handle_ = ::SSL_CTX_new(::TLS_server_method());
> if (handle_)
> {
> SSL_CTX_ctrl(handle_, 123, 0x0303, __null);
> SSL_CTX_ctrl(handle_, 124, 0x0303, __null);
> }
> break;
># 264 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> case context::sslv23:
> handle_ = ::SSL_CTX_new(::TLS_method());
> break;
> case context::sslv23_client:
> handle_ = ::SSL_CTX_new(::TLS_client_method());
> break;
> case context::sslv23_server:
> handle_ = ::SSL_CTX_new(::TLS_server_method());
> break;
>
>
>
> case context::tls:
> handle_ = ::SSL_CTX_new(::TLS_method());
> if (handle_)
> SSL_CTX_ctrl(handle_, 123, 0x0301, __null);
> break;
> case context::tls_client:
> handle_ = ::SSL_CTX_new(::TLS_client_method());
> if (handle_)
> SSL_CTX_ctrl(handle_, 123, 0x0301, __null);
> break;
> case context::tls_server:
> handle_ = ::SSL_CTX_new(::TLS_server_method());
> if (handle_)
> SSL_CTX_ctrl(handle_, 123, 0x0301, __null);
> break;
># 309 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> default:
> handle_ = ::SSL_CTX_new(0);
> break;
> }
>
> if (handle_ == 0)
> {
> boost::system::error_code ec(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> boost::asio::detail::throw_error(ec, "context");
> }
>
> set_options(no_compression);
>}
>
>
>context::context(context&& other)
>{
> handle_ = other.handle_;
> other.handle_ = 0;
>}
>
>context& context::operator=(context&& other)
>{
> context tmp(static_cast<context&&>(*this));
> handle_ = other.handle_;
> other.handle_ = 0;
> return *this;
>}
>
>
>context::~context()
>{
> if (handle_)
> {
>
> void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
>
>
>
> if (cb_userdata)
> {
> detail::password_callback_base* callback =
> static_cast<detail::password_callback_base*>(
> cb_userdata);
> delete callback;
>
> ::SSL_CTX_set_default_passwd_cb_userdata(handle_, 0);
>
>
>
> }
>
> if ((SSL_CTX_get_ex_data(handle_,0)))
> {
> detail::verify_callback_base* callback =
> static_cast<detail::verify_callback_base*>(
> (SSL_CTX_get_ex_data(handle_,0)));
> delete callback;
> (SSL_CTX_set_ex_data(handle_,0,(char *)0));
> }
>
> ::SSL_CTX_free(handle_);
> }
>}
>
>context::native_handle_type context::native_handle()
>{
> return handle_;
>}
>
>void context::clear_options(context::options o)
>{
> boost::system::error_code ec;
> clear_options(o, ec);
> boost::asio::detail::throw_error(ec, "clear_options");
>}
>
>boost::system::error_code context::clear_options(
> context::options o, boost::system::error_code& ec)
>{
># 403 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> ::SSL_CTX_clear_options(handle_, o);
>
> ec = boost::system::error_code();
>
>
>
>
>
>
> return ec;
>}
>
>void context::set_options(context::options o)
>{
> boost::system::error_code ec;
> set_options(o, ec);
> boost::asio::detail::throw_error(ec, "set_options");
>}
>
>boost::system::error_code context::set_options(
> context::options o, boost::system::error_code& ec)
>{
># 436 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> ::SSL_CTX_set_options(handle_, o);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::set_verify_mode(verify_mode v)
>{
> boost::system::error_code ec;
> set_verify_mode(v, ec);
> boost::asio::detail::throw_error(ec, "set_verify_mode");
>}
>
>boost::system::error_code context::set_verify_mode(
> verify_mode v, boost::system::error_code& ec)
>{
> ::SSL_CTX_set_verify(handle_, v, ::SSL_CTX_get_verify_callback(handle_));
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::set_verify_depth(int depth)
>{
> boost::system::error_code ec;
> set_verify_depth(depth, ec);
> boost::asio::detail::throw_error(ec, "set_verify_depth");
>}
>
>boost::system::error_code context::set_verify_depth(
> int depth, boost::system::error_code& ec)
>{
> ::SSL_CTX_set_verify_depth(handle_, depth);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::load_verify_file(const std::string& filename)
>{
> boost::system::error_code ec;
> load_verify_file(filename, ec);
> boost::asio::detail::throw_error(ec, "load_verify_file");
>}
>
>boost::system::error_code context::load_verify_file(
> const std::string& filename, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> if (::SSL_CTX_load_verify_locations(handle_, filename.c_str(), 0) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::add_certificate_authority(const const_buffer& ca)
>{
> boost::system::error_code ec;
> add_certificate_authority(ca, ec);
> boost::asio::detail::throw_error(ec, "add_certificate_authority");
>}
>
>boost::system::error_code context::add_certificate_authority(
> const const_buffer& ca, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> bio_cleanup bio = { make_buffer_bio(ca) };
> if (bio.p)
> {
> x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };
> if (cert.p)
> {
> if (X509_STORE* store = ::SSL_CTX_get_cert_store(handle_))
> {
> if (::X509_STORE_add_cert(store, cert.p) == 1)
> {
> ec = boost::system::error_code();
> return ec;
> }
> }
> }
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>void context::set_default_verify_paths()
>{
> boost::system::error_code ec;
> set_default_verify_paths(ec);
> boost::asio::detail::throw_error(ec, "set_default_verify_paths");
>}
>
>boost::system::error_code context::set_default_verify_paths(
> boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> if (::SSL_CTX_set_default_verify_paths(handle_) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::add_verify_path(const std::string& path)
>{
> boost::system::error_code ec;
> add_verify_path(path, ec);
> boost::asio::detail::throw_error(ec, "add_verify_path");
>}
>
>boost::system::error_code context::add_verify_path(
> const std::string& path, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> if (::SSL_CTX_load_verify_locations(handle_, 0, path.c_str()) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::use_certificate(
> const const_buffer& certificate, file_format format)
>{
> boost::system::error_code ec;
> use_certificate(certificate, format, ec);
> boost::asio::detail::throw_error(ec, "use_certificate");
>}
>
>boost::system::error_code context::use_certificate(
> const const_buffer& certificate, file_format format,
> boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> if (format == context_base::asn1)
> {
> if (::SSL_CTX_use_certificate_ASN1(handle_,
> static_cast<int>(certificate.size()),
> static_cast<const unsigned char*>(certificate.data())) == 1)
> {
> ec = boost::system::error_code();
> return ec;
> }
> }
> else if (format == context_base::pem)
> {
> bio_cleanup bio = { make_buffer_bio(certificate) };
> if (bio.p)
> {
> x509_cleanup cert = { ::PEM_read_bio_X509(bio.p, 0, 0, 0) };
> if (cert.p)
> {
> if (::SSL_CTX_use_certificate(handle_, cert.p) == 1)
> {
> ec = boost::system::error_code();
> return ec;
> }
> }
> }
> }
> else
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>void context::use_certificate_file(
> const std::string& filename, file_format format)
>{
> boost::system::error_code ec;
> use_certificate_file(filename, format, ec);
> boost::asio::detail::throw_error(ec, "use_certificate_file");
>}
>
>boost::system::error_code context::use_certificate_file(
> const std::string& filename, file_format format,
> boost::system::error_code& ec)
>{
> int file_type;
> switch (format)
> {
> case context_base::asn1:
> file_type = 2;
> break;
> case context_base::pem:
> file_type = 1;
> break;
> default:
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
> }
>
> ::ERR_clear_error();
>
> if (::SSL_CTX_use_certificate_file(handle_, filename.c_str(), file_type) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::use_certificate_chain(const const_buffer& chain)
>{
> boost::system::error_code ec;
> use_certificate_chain(chain, ec);
> boost::asio::detail::throw_error(ec, "use_certificate_chain");
>}
>
>boost::system::error_code context::use_certificate_chain(
> const const_buffer& chain, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> bio_cleanup bio = { make_buffer_bio(chain) };
> if (bio.p)
> {
>
> pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
> void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
>
>
>
>
> x509_cleanup cert = {
> ::PEM_read_bio_X509_AUX(bio.p, 0,
> callback,
> cb_userdata) };
> if (!cert.p)
> {
> ec = boost::system::error_code(9,
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> int result = ::SSL_CTX_use_certificate(handle_, cert.p);
> if (result == 0 || ::ERR_peek_error() != 0)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
>
> ::SSL_CTX_ctrl(handle_,88,0,(char *)__null);
># 727 "/usr/include/boost/asio/ssl/impl/context.ipp" 3 4
> while (X509* cacert = ::PEM_read_bio_X509(bio.p, 0,
> callback,
> cb_userdata))
> {
> if (!::SSL_CTX_ctrl(handle_,14,0,(char *)cacert))
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
> }
>
> result = ::ERR_peek_last_error();
> if (((int)(((result) >> 24L) & 0x0FFL) == 9)
> && ((int)( (result) & 0xFFFL) == 108))
> {
> ::ERR_clear_error();
> ec = boost::system::error_code();
> return ec;
> }
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>void context::use_certificate_chain_file(const std::string& filename)
>{
> boost::system::error_code ec;
> use_certificate_chain_file(filename, ec);
> boost::asio::detail::throw_error(ec, "use_certificate_chain_file");
>}
>
>boost::system::error_code context::use_certificate_chain_file(
> const std::string& filename, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> if (::SSL_CTX_use_certificate_chain_file(handle_, filename.c_str()) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::use_private_key(
> const const_buffer& private_key, context::file_format format)
>{
> boost::system::error_code ec;
> use_private_key(private_key, format, ec);
> boost::asio::detail::throw_error(ec, "use_private_key");
>}
>
>boost::system::error_code context::use_private_key(
> const const_buffer& private_key, context::file_format format,
> boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
>
> pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
> void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
>
>
>
>
>
> bio_cleanup bio = { make_buffer_bio(private_key) };
> if (bio.p)
> {
> evp_pkey_cleanup evp_private_key = { 0 };
> switch (format)
> {
> case context_base::asn1:
> evp_private_key.p = ::d2i_PrivateKey_bio(bio.p, 0);
> break;
> case context_base::pem:
> evp_private_key.p = ::PEM_read_bio_PrivateKey(
> bio.p, 0, callback,
> cb_userdata);
> break;
> default:
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
> }
>
> if (evp_private_key.p)
> {
> if (::SSL_CTX_use_PrivateKey(handle_, evp_private_key.p) == 1)
> {
> ec = boost::system::error_code();
> return ec;
> }
> }
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>void context::use_private_key_file(
> const std::string& filename, context::file_format format)
>{
> boost::system::error_code ec;
> use_private_key_file(filename, format, ec);
> boost::asio::detail::throw_error(ec, "use_private_key_file");
>}
>
>void context::use_rsa_private_key(
> const const_buffer& private_key, context::file_format format)
>{
> boost::system::error_code ec;
> use_rsa_private_key(private_key, format, ec);
> boost::asio::detail::throw_error(ec, "use_rsa_private_key");
>}
>
>boost::system::error_code context::use_rsa_private_key(
> const const_buffer& private_key, context::file_format format,
> boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
>
> pem_password_cb* callback = ::SSL_CTX_get_default_passwd_cb(handle_);
> void* cb_userdata = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
>
>
>
>
>
> bio_cleanup bio = { make_buffer_bio(private_key) };
> if (bio.p)
> {
> rsa_cleanup rsa_private_key = { 0 };
> switch (format)
> {
> case context_base::asn1:
> rsa_private_key.p = ::d2i_RSAPrivateKey_bio(bio.p, 0);
> break;
> case context_base::pem:
> rsa_private_key.p = ::PEM_read_bio_RSAPrivateKey(
> bio.p, 0, callback,
> cb_userdata);
> break;
> default:
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
> }
>
> if (rsa_private_key.p)
> {
> if (::SSL_CTX_use_RSAPrivateKey(handle_, rsa_private_key.p) == 1)
> {
> ec = boost::system::error_code();
> return ec;
> }
> }
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>boost::system::error_code context::use_private_key_file(
> const std::string& filename, context::file_format format,
> boost::system::error_code& ec)
>{
> int file_type;
> switch (format)
> {
> case context_base::asn1:
> file_type = 2;
> break;
> case context_base::pem:
> file_type = 1;
> break;
> default:
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
> }
>
> ::ERR_clear_error();
>
> if (::SSL_CTX_use_PrivateKey_file(handle_, filename.c_str(), file_type) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::use_rsa_private_key_file(
> const std::string& filename, context::file_format format)
>{
> boost::system::error_code ec;
> use_rsa_private_key_file(filename, format, ec);
> boost::asio::detail::throw_error(ec, "use_rsa_private_key_file");
>}
>
>boost::system::error_code context::use_rsa_private_key_file(
> const std::string& filename, context::file_format format,
> boost::system::error_code& ec)
>{
> int file_type;
> switch (format)
> {
> case context_base::asn1:
> file_type = 2;
> break;
> case context_base::pem:
> file_type = 1;
> break;
> default:
> {
> ec = boost::asio::error::invalid_argument;
> return ec;
> }
> }
>
> ::ERR_clear_error();
>
> if (::SSL_CTX_use_RSAPrivateKey_file(
> handle_, filename.c_str(), file_type) != 1)
> {
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
> }
>
> ec = boost::system::error_code();
> return ec;
>}
>
>void context::use_tmp_dh(const const_buffer& dh)
>{
> boost::system::error_code ec;
> use_tmp_dh(dh, ec);
> boost::asio::detail::throw_error(ec, "use_tmp_dh");
>}
>
>boost::system::error_code context::use_tmp_dh(
> const const_buffer& dh, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> bio_cleanup bio = { make_buffer_bio(dh) };
> if (bio.p)
> {
> return do_use_tmp_dh(bio.p, ec);
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>void context::use_tmp_dh_file(const std::string& filename)
>{
> boost::system::error_code ec;
> use_tmp_dh_file(filename, ec);
> boost::asio::detail::throw_error(ec, "use_tmp_dh_file");
>}
>
>boost::system::error_code context::use_tmp_dh_file(
> const std::string& filename, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> bio_cleanup bio = { ::BIO_new_file(filename.c_str(), "r") };
> if (bio.p)
> {
> return do_use_tmp_dh(bio.p, ec);
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>boost::system::error_code context::do_use_tmp_dh(
> BIO* bio, boost::system::error_code& ec)
>{
> ::ERR_clear_error();
>
> dh_cleanup dh = { ::PEM_read_bio_DHparams(bio, 0, 0, 0) };
> if (dh.p)
> {
> if (::SSL_CTX_ctrl(handle_,3,0,(char *)dh.p) == 1)
> {
> ec = boost::system::error_code();
> return ec;
> }
> }
>
> ec = boost::system::error_code(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> return ec;
>}
>
>boost::system::error_code context::do_set_verify_callback(
> detail::verify_callback_base* callback, boost::system::error_code& ec)
>{
> if ((SSL_CTX_get_ex_data(handle_,0)))
> {
> delete static_cast<detail::verify_callback_base*>(
> (SSL_CTX_get_ex_data(handle_,0)));
> }
>
> (SSL_CTX_set_ex_data(handle_,0,(char *)callback));
>
> ::SSL_CTX_set_verify(handle_,
> ::SSL_CTX_get_verify_mode(handle_),
> &context::verify_callback_function);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>int context::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
>{
> if (ctx)
> {
> if (SSL* ssl = static_cast<SSL*>(
> ::X509_STORE_CTX_get_ex_data(
> ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))
> {
> if (SSL_CTX* handle = ::SSL_get_SSL_CTX(ssl))
> {
> if ((SSL_CTX_get_ex_data(handle,0)))
> {
> detail::verify_callback_base* callback =
> static_cast<detail::verify_callback_base*>(
> (SSL_CTX_get_ex_data(handle,0)));
>
> verify_context verify_ctx(ctx);
> return callback->call(preverified != 0, verify_ctx) ? 1 : 0;
> }
> }
> }
> }
>
> return 0;
>}
>
>boost::system::error_code context::do_set_password_callback(
> detail::password_callback_base* callback, boost::system::error_code& ec)
>{
>
> void* old_callback = ::SSL_CTX_get_default_passwd_cb_userdata(handle_);
> ::SSL_CTX_set_default_passwd_cb_userdata(handle_, callback);
>
>
>
>
>
> if (old_callback)
> delete static_cast<detail::password_callback_base*>(
> old_callback);
>
> SSL_CTX_set_default_passwd_cb(handle_, &context::password_callback_function);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>int context::password_callback_function(
> char* buf, int size, int purpose, void* data)
>{
> using namespace std;
>
> if (data)
> {
> detail::password_callback_base* callback =
> static_cast<detail::password_callback_base*>(data);
>
> std::string passwd = callback->call(static_cast<std::size_t>(size),
> purpose ? context_base::for_writing : context_base::for_reading);
>
>
>
>
> *buf = '\0';
> if (size > 0)
> strncat(buf, passwd.c_str(), size - 1);
>
>
> return static_cast<int>(strlen(buf));
> }
>
> return 0;
>}
>
>BIO* context::make_buffer_bio(const const_buffer& b)
>{
> return ::BIO_new_mem_buf(
> const_cast<void*>(b.data()),
> static_cast<int>(b.size()));
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 1157 "/usr/include/boost/asio/ssl/impl/context.ipp" 2 3 4
># 758 "/usr/include/boost/asio/ssl/context.hpp" 2 3 4
># 19 "/usr/include/boost/asio/ssl.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
># 61 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 3 4
>class rfc2818_verification
>{
>public:
>
> typedef bool result_type;
>
>
> explicit rfc2818_verification(const std::string& host)
> : host_(host)
> {
> }
>
>
> inline bool operator()(bool preverified, verify_context& ctx) const;
>
>private:
>
> inline static bool match_pattern(const char* pattern,
> std::size_t pattern_length, const char* host);
>
>
>
> std::string host_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 91 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 1 3 4
># 20 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 3 4
># 1 "/usr/include/c++/8/cctype" 1 3 4
># 39 "/usr/include/c++/8/cctype" 3 4
> 
># 40 "/usr/include/c++/8/cctype" 3
># 21 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 2 3 4
># 1 "/usr/include/c++/8/cstring" 1 3 4
># 39 "/usr/include/c++/8/cstring" 3 4
> 
># 40 "/usr/include/c++/8/cstring" 3
># 22 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 2 3 4
>
># 1 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>bool rfc2818_verification::operator()(
> bool preverified, verify_context& ctx) const
>{
> using namespace std;
>
>
> if (!preverified)
> return false;
>
>
> int depth = X509_STORE_CTX_get_error_depth(ctx.native_handle());
> if (depth > 0)
> return true;
>
>
>
> boost::system::error_code ec;
> ip::address address = ip::make_address(host_, ec);
> bool is_address = !ec;
>
> X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
>
>
>
> GENERAL_NAMES* gens = static_cast<GENERAL_NAMES*>(
> X509_get_ext_d2i(cert, 85, 0, 0));
> for (int i = 0; i < sk_GENERAL_NAME_num(gens); ++i)
> {
> GENERAL_NAME* gen = sk_GENERAL_NAME_value(gens, i);
> if (gen->type == 2 && !is_address)
> {
> ASN1_IA5STRING* domain = gen->d.dNSName;
> if (domain->type == 22 && domain->data && domain->length)
> {
> const char* pattern = reinterpret_cast<const char*>(domain->data);
> std::size_t pattern_length = domain->length;
> if (match_pattern(pattern, pattern_length, host_.c_str()))
> {
> GENERAL_NAMES_free(gens);
> return true;
> }
> }
> }
> else if (gen->type == 7 && is_address)
> {
> ASN1_OCTET_STRING* ip_address = gen->d.iPAddress;
> if (ip_address->type == 4 && ip_address->data)
> {
> if (address.is_v4() && ip_address->length == 4)
> {
> ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
> if (memcmp(bytes.data(), ip_address->data, 4) == 0)
> {
> GENERAL_NAMES_free(gens);
> return true;
> }
> }
> else if (address.is_v6() && ip_address->length == 16)
> {
> ip::address_v6::bytes_type bytes = address.to_v6().to_bytes();
> if (memcmp(bytes.data(), ip_address->data, 16) == 0)
> {
> GENERAL_NAMES_free(gens);
> return true;
> }
> }
> }
> }
> }
> GENERAL_NAMES_free(gens);
>
>
>
> X509_NAME* name = X509_get_subject_name(cert);
> int i = -1;
> ASN1_STRING* common_name = 0;
> while ((i = X509_NAME_get_index_by_NID(name, 13, i)) >= 0)
> {
> X509_NAME_ENTRY* name_entry = X509_NAME_get_entry(name, i);
> common_name = X509_NAME_ENTRY_get_data(name_entry);
> }
> if (common_name && common_name->data && common_name->length)
> {
> const char* pattern = reinterpret_cast<const char*>(common_name->data);
> std::size_t pattern_length = common_name->length;
> if (match_pattern(pattern, pattern_length, host_.c_str()))
> return true;
> }
>
> return false;
>}
>
>bool rfc2818_verification::match_pattern(const char* pattern,
> std::size_t pattern_length, const char* host)
>{
> using namespace std;
>
> const char* p = pattern;
> const char* p_end = p + pattern_length;
> const char* h = host;
>
> while (p != p_end && *h)
> {
> if (*p == '*')
> {
> ++p;
> while (*h && *h != '.')
> if (match_pattern(p, p_end - p, h++))
> return true;
> }
> else if (tolower(*p) == tolower(*h))
> {
> ++p;
> ++h;
> }
> else
> {
> return false;
> }
> }
>
> return p == p_end && !*h;
>}
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 161 "/usr/include/boost/asio/ssl/impl/rfc2818_verification.ipp" 2 3 4
># 94 "/usr/include/boost/asio/ssl/rfc2818_verification.hpp" 2 3 4
># 22 "/usr/include/boost/asio/ssl.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/stream.hpp" 1 3 4
># 26 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/detail/buffered_handshake_op.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ssl/detail/buffered_handshake_op.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/detail/engine.hpp" 1 3 4
># 24 "/usr/include/boost/asio/ssl/detail/engine.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/stream_base.hpp" 1 3 4
># 20 "/usr/include/boost/asio/ssl/stream_base.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 21 "/usr/include/boost/asio/ssl/stream_base.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>
>
>
>class stream_base
>{
>public:
>
> enum handshake_type
> {
>
> client,
>
>
> server
> };
>
>protected:
>
> ~stream_base()
> {
> }
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 53 "/usr/include/boost/asio/ssl/stream_base.hpp" 2 3 4
># 25 "/usr/include/boost/asio/ssl/detail/engine.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 28 "/usr/include/boost/asio/ssl/detail/engine.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class engine
>{
>public:
> enum want
> {
>
>
>
> want_input_and_retry = -2,
>
>
>
>
> want_output_and_retry = -1,
>
>
>
> want_nothing = 0,
>
>
>
>
> want_output = 1
> };
>
>
> inline explicit engine(SSL_CTX* context);
>
>
> inline ~engine();
>
>
> inline SSL* native_handle();
>
>
> inline boost::system::error_code set_verify_mode(
> verify_mode v, boost::system::error_code& ec);
>
>
> inline boost::system::error_code set_verify_depth(
> int depth, boost::system::error_code& ec);
>
>
> inline boost::system::error_code set_verify_callback(
> verify_callback_base* callback, boost::system::error_code& ec);
>
>
>
> inline want handshake(
> stream_base::handshake_type type, boost::system::error_code& ec);
>
>
> inline want shutdown(boost::system::error_code& ec);
>
>
> inline want write(const boost::asio::const_buffer& data,
> boost::system::error_code& ec, std::size_t& bytes_transferred);
>
>
> inline want read(const boost::asio::mutable_buffer& data,
> boost::system::error_code& ec, std::size_t& bytes_transferred);
>
>
> inline boost::asio::mutable_buffer get_output(
> const boost::asio::mutable_buffer& data);
>
>
> inline boost::asio::const_buffer put_input(
> const boost::asio::const_buffer& data);
>
>
>
>
> inline const boost::system::error_code& map_error_code(
> boost::system::error_code& ec) const;
>
>private:
>
> engine(const engine&);
> engine& operator=(const engine&);
>
>
> inline static int verify_callback_function(
> int preverified, X509_STORE_CTX* ctx);
># 128 "/usr/include/boost/asio/ssl/detail/engine.hpp" 3 4
> inline want perform(int (engine::* op)(void*, std::size_t),
> void* data, std::size_t length, boost::system::error_code& ec,
> std::size_t* bytes_transferred);
>
>
> inline int do_accept(void*, std::size_t);
>
>
> inline int do_connect(void*, std::size_t);
>
>
> inline int do_shutdown(void*, std::size_t);
>
>
> inline int do_read(void* data, std::size_t length);
>
>
> inline int do_write(void* data, std::size_t length);
>
> SSL* ssl_;
> BIO* ext_bio_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 157 "/usr/include/boost/asio/ssl/detail/engine.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 1 3 4
># 22 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 3 4
># 1 "/usr/include/boost/asio/ssl/detail/engine.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 2 3 4
>
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 27 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>engine::engine(SSL_CTX* context)
> : ssl_(::SSL_new(context))
>{
> if (!ssl_)
> {
> boost::system::error_code ec(
> static_cast<int>(::ERR_get_error()),
> boost::asio::error::get_ssl_category());
> boost::asio::detail::throw_error(ec, "engine");
> }
>
>
>
>
>
> ::SSL_ctrl((ssl_),33,(0x00000001U),__null);
> ::SSL_ctrl((ssl_),33,(0x00000002U),__null);
>
> ::SSL_ctrl((ssl_),33,(0x00000010U),__null);
>
>
> ::BIO* int_bio = 0;
> ::BIO_new_bio_pair(&int_bio, 0, &ext_bio_, 0);
> ::SSL_set_bio(ssl_, int_bio, int_bio);
>}
>
>engine::~engine()
>{
> if ((SSL_get_ex_data(ssl_,0)))
> {
> delete static_cast<verify_callback_base*>((SSL_get_ex_data(ssl_,0)));
> (SSL_set_ex_data(ssl_,0,(char *)0));
> }
>
> ::BIO_free(ext_bio_);
> ::SSL_free(ssl_);
>}
>
>SSL* engine::native_handle()
>{
> return ssl_;
>}
>
>boost::system::error_code engine::set_verify_mode(
> verify_mode v, boost::system::error_code& ec)
>{
> ::SSL_set_verify(ssl_, v, ::SSL_get_verify_callback(ssl_));
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code engine::set_verify_depth(
> int depth, boost::system::error_code& ec)
>{
> ::SSL_set_verify_depth(ssl_, depth);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>boost::system::error_code engine::set_verify_callback(
> verify_callback_base* callback, boost::system::error_code& ec)
>{
> if ((SSL_get_ex_data(ssl_,0)))
> delete static_cast<verify_callback_base*>((SSL_get_ex_data(ssl_,0)));
>
> (SSL_set_ex_data(ssl_,0,(char *)callback));
>
> ::SSL_set_verify(ssl_, ::SSL_get_verify_mode(ssl_),
> &engine::verify_callback_function);
>
> ec = boost::system::error_code();
> return ec;
>}
>
>int engine::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
>{
> if (ctx)
> {
> if (SSL* ssl = static_cast<SSL*>(
> ::X509_STORE_CTX_get_ex_data(
> ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))
> {
> if ((SSL_get_ex_data(ssl,0)))
> {
> verify_callback_base* callback =
> static_cast<verify_callback_base*>(
> (SSL_get_ex_data(ssl,0)));
>
> verify_context verify_ctx(ctx);
> return callback->call(preverified != 0, verify_ctx) ? 1 : 0;
> }
> }
> }
>
> return 0;
>}
>
>engine::want engine::handshake(
> stream_base::handshake_type type, boost::system::error_code& ec)
>{
> return perform((type == boost::asio::ssl::stream_base::client)
> ? &engine::do_connect : &engine::do_accept, 0, 0, ec, 0);
>}
>
>engine::want engine::shutdown(boost::system::error_code& ec)
>{
> return perform(&engine::do_shutdown, 0, 0, ec, 0);
>}
>
>engine::want engine::write(const boost::asio::const_buffer& data,
> boost::system::error_code& ec, std::size_t& bytes_transferred)
>{
> if (data.size() == 0)
> {
> ec = boost::system::error_code();
> return engine::want_nothing;
> }
>
> return perform(&engine::do_write,
> const_cast<void*>(data.data()),
> data.size(), ec, &bytes_transferred);
>}
>
>engine::want engine::read(const boost::asio::mutable_buffer& data,
> boost::system::error_code& ec, std::size_t& bytes_transferred)
>{
> if (data.size() == 0)
> {
> ec = boost::system::error_code();
> return engine::want_nothing;
> }
>
> return perform(&engine::do_read, data.data(),
> data.size(), ec, &bytes_transferred);
>}
>
>boost::asio::mutable_buffer engine::get_output(
> const boost::asio::mutable_buffer& data)
>{
> int length = ::BIO_read(ext_bio_,
> data.data(), static_cast<int>(data.size()));
>
> return boost::asio::buffer(data,
> length > 0 ? static_cast<std::size_t>(length) : 0);
>}
>
>boost::asio::const_buffer engine::put_input(
> const boost::asio::const_buffer& data)
>{
> int length = ::BIO_write(ext_bio_,
> data.data(), static_cast<int>(data.size()));
>
> return boost::asio::buffer(data +
> (length > 0 ? static_cast<std::size_t>(length) : 0));
>}
>
>const boost::system::error_code& engine::map_error_code(
> boost::system::error_code& ec) const
>{
>
> if (ec != boost::asio::error::eof)
> return ec;
>
>
> if ((int)BIO_ctrl(ext_bio_,13,0,__null))
> {
> ec = boost::asio::ssl::error::stream_truncated;
> return ec;
> }
># 213 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 3 4
> if ((::SSL_get_shutdown(ssl_) & 2) == 0)
> {
> ec = boost::asio::ssl::error::stream_truncated;
> }
>
> return ec;
>}
># 229 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 3 4
>engine::want engine::perform(int (engine::* op)(void*, std::size_t),
> void* data, std::size_t length, boost::system::error_code& ec,
> std::size_t* bytes_transferred)
>{
> std::size_t pending_output_before = ::BIO_ctrl_pending(ext_bio_);
> ::ERR_clear_error();
> int result = (this->*op)(data, length);
> int ssl_error = ::SSL_get_error(ssl_, result);
> int sys_error = static_cast<int>(::ERR_get_error());
> std::size_t pending_output_after = ::BIO_ctrl_pending(ext_bio_);
>
> if (ssl_error == 1)
> {
> ec = boost::system::error_code(sys_error,
> boost::asio::error::get_ssl_category());
> return want_nothing;
> }
>
> if (ssl_error == 5)
> {
> ec = boost::system::error_code(sys_error,
> boost::asio::error::get_system_category());
> return want_nothing;
> }
>
> if (result > 0 && bytes_transferred)
> *bytes_transferred = static_cast<std::size_t>(result);
>
> if (ssl_error == 3)
> {
> ec = boost::system::error_code();
> return want_output_and_retry;
> }
> else if (pending_output_after > pending_output_before)
> {
> ec = boost::system::error_code();
> return result > 0 ? want_output : want_output_and_retry;
> }
> else if (ssl_error == 2)
> {
> ec = boost::system::error_code();
> return want_input_and_retry;
> }
> else if (::SSL_get_shutdown(ssl_) & 2)
> {
> ec = boost::asio::error::eof;
> return want_nothing;
> }
> else
> {
> ec = boost::system::error_code();
> return want_nothing;
> }
>}
>
>int engine::do_accept(void*, std::size_t)
>{
>
>
>
> return ::SSL_accept(ssl_);
>}
>
>int engine::do_connect(void*, std::size_t)
>{
> return ::SSL_connect(ssl_);
>}
>
>int engine::do_shutdown(void*, std::size_t)
>{
> int result = ::SSL_shutdown(ssl_);
> if (result == 0)
> result = ::SSL_shutdown(ssl_);
> return result;
>}
>
>int engine::do_read(void* data, std::size_t length)
>{
> return ::SSL_read(ssl_, data,
> length < 0x7fffffff ? static_cast<int>(length) : 0x7fffffff);
>}
>
>int engine::do_write(void* data, std::size_t length)
>{
> return ::SSL_write(ssl_, data,
> length < 0x7fffffff ? static_cast<int>(length) : 0x7fffffff);
>}
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 323 "/usr/include/boost/asio/ssl/detail/impl/engine.ipp" 2 3 4
># 160 "/usr/include/boost/asio/ssl/detail/engine.hpp" 2 3 4
># 21 "/usr/include/boost/asio/ssl/detail/buffered_handshake_op.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ssl/detail/buffered_handshake_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>template <typename ConstBufferSequence>
>class buffered_handshake_op
>{
>public:
> buffered_handshake_op(stream_base::handshake_type type,
> const ConstBufferSequence& buffers)
> : type_(type),
> buffers_(buffers),
> total_buffer_size_(boost::asio::buffer_size(buffers_))
> {
> }
>
> engine::want operator()(engine& eng,
> boost::system::error_code& ec,
> std::size_t& bytes_transferred) const
> {
> return this->process(eng, ec, bytes_transferred,
> boost::asio::buffer_sequence_begin(buffers_),
> boost::asio::buffer_sequence_end(buffers_));
> }
>
> template <typename Handler>
> void call_handler(Handler& handler,
> const boost::system::error_code& ec,
> const std::size_t& bytes_transferred) const
> {
> handler(ec, bytes_transferred);
> }
>
>private:
> template <typename Iterator>
> engine::want process(engine& eng,
> boost::system::error_code& ec,
> std::size_t& bytes_transferred,
> Iterator begin, Iterator end) const
> {
> Iterator iter = begin;
> std::size_t accumulated_size = 0;
>
> for (;;)
> {
> engine::want want = eng.handshake(type_, ec);
> if (want != engine::want_input_and_retry
> || bytes_transferred == total_buffer_size_)
> return want;
>
>
> while (iter != end)
> {
> const_buffer buffer(*iter);
>
>
> if (bytes_transferred >= accumulated_size + buffer.size())
> {
> accumulated_size += buffer.size();
> ++iter;
> continue;
> }
>
>
>
>
> if (bytes_transferred > accumulated_size)
> buffer = buffer + (bytes_transferred - accumulated_size);
>
>
>
> bytes_transferred += buffer.size();
> buffer = eng.put_input(buffer);
> bytes_transferred -= buffer.size();
> break;
> }
> }
> }
>
> stream_base::handshake_type type_;
> ConstBufferSequence buffers_;
> std::size_t total_buffer_size_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 115 "/usr/include/boost/asio/ssl/detail/buffered_handshake_op.hpp" 2 3 4
># 27 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/detail/handshake_op.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ssl/detail/handshake_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ssl/detail/handshake_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class handshake_op
>{
>public:
> handshake_op(stream_base::handshake_type type)
> : type_(type)
> {
> }
>
> engine::want operator()(engine& eng,
> boost::system::error_code& ec,
> std::size_t& bytes_transferred) const
> {
> bytes_transferred = 0;
> return eng.handshake(type_, ec);
> }
>
> template <typename Handler>
> void call_handler(Handler& handler,
> const boost::system::error_code& ec,
> const std::size_t&) const
> {
> handler(ec);
> }
>
>private:
> stream_base::handshake_type type_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 63 "/usr/include/boost/asio/ssl/detail/handshake_op.hpp" 2 3 4
># 28 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/detail/io.hpp" 1 3 4
># 21 "/usr/include/boost/asio/ssl/detail/io.hpp" 3 4
># 1 "/usr/include/boost/asio/ssl/detail/stream_core.hpp" 1 3 4
># 28 "/usr/include/boost/asio/ssl/detail/stream_core.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 29 "/usr/include/boost/asio/ssl/detail/stream_core.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>struct stream_core
>{
>
>
> enum { max_tls_record_size = 17 * 1024 };
>
> stream_core(SSL_CTX* context, boost::asio::io_context& io_context)
> : engine_(context),
> pending_read_(io_context),
> pending_write_(io_context),
> output_buffer_space_(max_tls_record_size),
> output_buffer_(boost::asio::buffer(output_buffer_space_)),
> input_buffer_space_(max_tls_record_size),
> input_buffer_(boost::asio::buffer(input_buffer_space_))
> {
> pending_read_.expires_at(neg_infin());
> pending_write_.expires_at(neg_infin());
> }
>
> ~stream_core()
> {
> }
>
>
> engine engine_;
>
>
>
> boost::asio::deadline_timer pending_read_;
>
>
> boost::asio::deadline_timer pending_write_;
>
>
> static boost::asio::deadline_timer::time_type neg_infin()
> {
> return boost::posix_time::neg_infin;
> }
>
>
> static boost::asio::deadline_timer::time_type pos_infin()
> {
> return boost::posix_time::pos_infin;
> }
>
>
> static boost::asio::deadline_timer::time_type expiry(
> const boost::asio::deadline_timer& timer)
> {
> return timer.expires_at();
> }
># 114 "/usr/include/boost/asio/ssl/detail/stream_core.hpp" 3 4
> std::vector<unsigned char> output_buffer_space_;
>
>
> const boost::asio::mutable_buffer output_buffer_;
>
>
> std::vector<unsigned char> input_buffer_space_;
>
>
> const boost::asio::mutable_buffer input_buffer_;
>
>
> boost::asio::const_buffer input_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 135 "/usr/include/boost/asio/ssl/detail/stream_core.hpp" 2 3 4
># 22 "/usr/include/boost/asio/ssl/detail/io.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 25 "/usr/include/boost/asio/ssl/detail/io.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>template <typename Stream, typename Operation>
>std::size_t io(Stream& next_layer, stream_core& core,
> const Operation& op, boost::system::error_code& ec)
>{
> std::size_t bytes_transferred = 0;
> do switch (op(core.engine_, ec, bytes_transferred))
> {
> case engine::want_input_and_retry:
>
>
>
> if (core.input_.size() == 0)
> core.input_ = boost::asio::buffer(core.input_buffer_,
> next_layer.read_some(core.input_buffer_, ec));
>
>
> core.input_ = core.engine_.put_input(core.input_);
>
>
> continue;
>
> case engine::want_output_and_retry:
>
>
>
> boost::asio::write(next_layer,
> core.engine_.get_output(core.output_buffer_), ec);
>
>
> continue;
>
> case engine::want_output:
>
>
>
> boost::asio::write(next_layer,
> core.engine_.get_output(core.output_buffer_), ec);
>
>
> core.engine_.map_error_code(ec);
> return bytes_transferred;
>
> default:
>
>
> core.engine_.map_error_code(ec);
> return bytes_transferred;
>
> } while (!ec);
>
>
> core.engine_.map_error_code(ec);
> return 0;
>}
>
>template <typename Stream, typename Operation, typename Handler>
>class io_op
>{
>public:
> io_op(Stream& next_layer, stream_core& core,
> const Operation& op, Handler& handler)
> : next_layer_(next_layer),
> core_(core),
> op_(op),
> start_(0),
> want_(engine::want_nothing),
> bytes_transferred_(0),
> handler_(static_cast<Handler&&>(handler))
> {
> }
>
>
> io_op(const io_op& other)
> : next_layer_(other.next_layer_),
> core_(other.core_),
> op_(other.op_),
> start_(other.start_),
> want_(other.want_),
> ec_(other.ec_),
> bytes_transferred_(other.bytes_transferred_),
> handler_(other.handler_)
> {
> }
>
> io_op(io_op&& other)
> : next_layer_(other.next_layer_),
> core_(other.core_),
> op_(other.op_),
> start_(other.start_),
> want_(other.want_),
> ec_(other.ec_),
> bytes_transferred_(other.bytes_transferred_),
> handler_(static_cast<Handler&&>(other.handler_))
> {
> }
>
>
> void operator()(boost::system::error_code ec,
> std::size_t bytes_transferred = ~std::size_t(0), int start = 0)
> {
> switch (start_ = start)
> {
> case 1:
> do
> {
> switch (want_ = op_(core_.engine_, ec_, bytes_transferred_))
> {
> case engine::want_input_and_retry:
>
>
>
> if (core_.input_.size() != 0)
> {
> core_.input_ = core_.engine_.put_input(core_.input_);
> continue;
> }
>
>
>
>
>
> if (core_.expiry(core_.pending_read_) == core_.neg_infin())
> {
>
> core_.pending_read_.expires_at(core_.pos_infin());
>
>
> next_layer_.async_read_some(
> boost::asio::buffer(core_.input_buffer_),
> static_cast<io_op&&>(*this));
> }
> else
> {
>
> core_.pending_read_.async_wait(static_cast<io_op&&>(*this));
> }
>
>
>
> return;
>
> case engine::want_output_and_retry:
> case engine::want_output:
>
>
>
>
>
> if (core_.expiry(core_.pending_write_) == core_.neg_infin())
> {
>
> core_.pending_write_.expires_at(core_.pos_infin());
>
>
> boost::asio::async_write(next_layer_,
> core_.engine_.get_output(core_.output_buffer_),
> static_cast<io_op&&>(*this));
> }
> else
> {
>
> core_.pending_write_.async_wait(static_cast<io_op&&>(*this));
> }
>
>
>
> return;
>
> default:
>
>
>
>
>
>
> if (start)
> {
> next_layer_.async_read_some(
> boost::asio::buffer(core_.input_buffer_, 0),
> static_cast<io_op&&>(*this));
>
>
>
> return;
> }
> else
> {
>
> break;
> }
> }
>
> default:
> if (bytes_transferred == ~std::size_t(0))
> bytes_transferred = 0;
> else if (!ec_)
> ec_ = ec;
>
> switch (want_)
> {
> case engine::want_input_and_retry:
>
>
> core_.input_ = boost::asio::buffer(
> core_.input_buffer_, bytes_transferred);
> core_.input_ = core_.engine_.put_input(core_.input_);
>
>
> core_.pending_read_.expires_at(core_.neg_infin());
>
>
> continue;
>
> case engine::want_output_and_retry:
>
>
> core_.pending_write_.expires_at(core_.neg_infin());
>
>
> continue;
>
> case engine::want_output:
>
>
> core_.pending_write_.expires_at(core_.neg_infin());
>
>
>
> default:
>
>
> op_.call_handler(handler_,
> core_.engine_.map_error_code(ec_),
> ec_ ? 0 : bytes_transferred_);
>
>
> return;
> }
> } while (!ec_);
>
>
> op_.call_handler(handler_, core_.engine_.map_error_code(ec_), 0);
> }
> }
>
>
> Stream& next_layer_;
> stream_core& core_;
> Operation op_;
> int start_;
> engine::want want_;
> boost::system::error_code ec_;
> std::size_t bytes_transferred_;
> Handler handler_;
>};
>
>template <typename Stream, typename Operation, typename Handler>
>inline void* asio_handler_allocate(std::size_t size,
> io_op<Stream, Operation, Handler>* this_handler)
>{
> return boost_asio_handler_alloc_helpers::allocate(
> size, this_handler->handler_);
>}
>
>template <typename Stream, typename Operation, typename Handler>
>inline void asio_handler_deallocate(void* pointer, std::size_t size,
> io_op<Stream, Operation, Handler>* this_handler)
>{
> boost_asio_handler_alloc_helpers::deallocate(
> pointer, size, this_handler->handler_);
>}
>
>template <typename Stream, typename Operation, typename Handler>
>inline bool asio_handler_is_continuation(
> io_op<Stream, Operation, Handler>* this_handler)
>{
> return this_handler->start_ == 0 ? true
> : boost_asio_handler_cont_helpers::is_continuation(this_handler->handler_);
>}
>
>template <typename Function, typename Stream,
> typename Operation, typename Handler>
>inline void asio_handler_invoke(Function& function,
> io_op<Stream, Operation, Handler>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Function, typename Stream,
> typename Operation, typename Handler>
>inline void asio_handler_invoke(const Function& function,
> io_op<Stream, Operation, Handler>* this_handler)
>{
> boost_asio_handler_invoke_helpers::invoke(
> function, this_handler->handler_);
>}
>
>template <typename Stream, typename Operation, typename Handler>
>inline void async_io(Stream& next_layer, stream_core& core,
> const Operation& op, Handler& handler)
>{
> io_op<Stream, Operation, Handler>(
> next_layer, core, op, handler)(
> boost::system::error_code(), 0, 1);
>}
>
>}
>}
>
>template <typename Stream, typename Operation,
> typename Handler, typename Allocator>
>struct associated_allocator<
> ssl::detail::io_op<Stream, Operation, Handler>, Allocator>
>{
> typedef typename associated_allocator<Handler, Allocator>::type type;
>
> static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
> const Allocator& a = Allocator()) noexcept
> {
> return associated_allocator<Handler, Allocator>::get(h.handler_, a);
> }
>};
>
>template <typename Stream, typename Operation,
> typename Handler, typename Executor>
>struct associated_executor<
> ssl::detail::io_op<Stream, Operation, Handler>, Executor>
>{
> typedef typename associated_executor<Handler, Executor>::type type;
>
> static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
> const Executor& ex = Executor()) noexcept
> {
> return associated_executor<Handler, Executor>::get(h.handler_, ex);
> }
>};
>
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 373 "/usr/include/boost/asio/ssl/detail/io.hpp" 2 3 4
># 29 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/detail/read_op.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ssl/detail/read_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/ssl/detail/read_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>template <typename MutableBufferSequence>
>class read_op
>{
>public:
> read_op(const MutableBufferSequence& buffers)
> : buffers_(buffers)
> {
> }
>
> engine::want operator()(engine& eng,
> boost::system::error_code& ec,
> std::size_t& bytes_transferred) const
> {
> boost::asio::mutable_buffer buffer =
> boost::asio::detail::buffer_sequence_adapter<boost::asio::mutable_buffer,
> MutableBufferSequence>::first(buffers_);
>
> return eng.read(buffer, ec, bytes_transferred);
> }
>
> template <typename Handler>
> void call_handler(Handler& handler,
> const boost::system::error_code& ec,
> const std::size_t& bytes_transferred) const
> {
> handler(ec, bytes_transferred);
> }
>
>private:
> MutableBufferSequence buffers_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 68 "/usr/include/boost/asio/ssl/detail/read_op.hpp" 2 3 4
># 30 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
># 1 "/usr/include/boost/asio/ssl/detail/shutdown_op.hpp" 1 3 4
># 22 "/usr/include/boost/asio/ssl/detail/shutdown_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 23 "/usr/include/boost/asio/ssl/detail/shutdown_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>class shutdown_op
>{
>public:
> engine::want operator()(engine& eng,
> boost::system::error_code& ec,
> std::size_t& bytes_transferred) const
> {
> bytes_transferred = 0;
> return eng.shutdown(ec);
> }
>
> template <typename Handler>
> void call_handler(Handler& handler,
> const boost::system::error_code& ec,
> const std::size_t&) const
> {
> handler(ec);
> }
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 55 "/usr/include/boost/asio/ssl/detail/shutdown_op.hpp" 2 3 4
># 31 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
>
># 1 "/usr/include/boost/asio/ssl/detail/write_op.hpp" 1 3 4
># 23 "/usr/include/boost/asio/ssl/detail/write_op.hpp" 3 4
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 24 "/usr/include/boost/asio/ssl/detail/write_op.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
>namespace detail {
>
>template <typename ConstBufferSequence>
>class write_op
>{
>public:
> write_op(const ConstBufferSequence& buffers)
> : buffers_(buffers)
> {
> }
>
> engine::want operator()(engine& eng,
> boost::system::error_code& ec,
> std::size_t& bytes_transferred) const
> {
> boost::asio::const_buffer buffer =
> boost::asio::detail::buffer_sequence_adapter<boost::asio::const_buffer,
> ConstBufferSequence>::first(buffers_);
>
> return eng.write(buffer, ec, bytes_transferred);
> }
>
> template <typename Handler>
> void call_handler(Handler& handler,
> const boost::system::error_code& ec,
> const std::size_t& bytes_transferred) const
> {
> handler(ec, bytes_transferred);
> }
>
>private:
> ConstBufferSequence buffers_;
>};
>
>}
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 68 "/usr/include/boost/asio/ssl/detail/write_op.hpp" 2 3 4
># 33 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
>
>
># 1 "/usr/include/boost/asio/detail/push_options.hpp" 1 3 4
># 71 "/usr/include/boost/asio/detail/push_options.hpp" 3 4
>#pragma GCC visibility push (default)
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
># 36 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
>
>namespace boost {
>namespace asio {
>namespace ssl {
># 63 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
>template <typename Stream>
>class stream :
> public stream_base,
> private noncopyable
>{
>public:
>
> typedef SSL* native_handle_type;
>
>
> struct impl_struct
> {
> SSL* ssl;
> };
>
>
> typedef typename remove_reference<Stream>::type next_layer_type;
>
>
> typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
>
>
> typedef typename lowest_layer_type::executor_type executor_type;
># 97 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename Arg>
> stream(Arg&& arg, context& ctx)
> : next_layer_(static_cast<Arg&&>(arg)),
> core_(ctx.native_handle(),
> next_layer_.lowest_layer().get_executor().context())
> {
> }
># 119 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> ~stream()
> {
> }
># 130 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> executor_type get_executor() noexcept
> {
> return next_layer_.lowest_layer().get_executor();
> }
>
>
>
>
> boost::asio::io_context& get_io_context()
> {
> return next_layer_.lowest_layer().get_io_context();
> }
>
>
>
> boost::asio::io_context& get_io_service()
> {
> return next_layer_.lowest_layer().get_io_service();
> }
># 175 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> native_handle_type native_handle()
> {
> return core_.engine_.native_handle();
> }
># 188 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> const next_layer_type& next_layer() const
> {
> return next_layer_;
> }
># 201 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> next_layer_type& next_layer()
> {
> return next_layer_;
> }
># 214 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> lowest_layer_type& lowest_layer()
> {
> return next_layer_.lowest_layer();
> }
># 227 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> const lowest_layer_type& lowest_layer() const
> {
> return next_layer_.lowest_layer();
> }
># 244 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> void set_verify_mode(verify_mode v)
> {
> boost::system::error_code ec;
> set_verify_mode(v, ec);
> boost::asio::detail::throw_error(ec, "set_verify_mode");
> }
># 263 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> boost::system::error_code set_verify_mode(
> verify_mode v, boost::system::error_code& ec)
> {
> core_.engine_.set_verify_mode(v, ec);
> return ec;
> }
># 282 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> void set_verify_depth(int depth)
> {
> boost::system::error_code ec;
> set_verify_depth(depth, ec);
> boost::asio::detail::throw_error(ec, "set_verify_depth");
> }
># 301 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> boost::system::error_code set_verify_depth(
> int depth, boost::system::error_code& ec)
> {
> core_.engine_.set_verify_depth(depth, ec);
> return ec;
> }
># 326 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename VerifyCallback>
> void set_verify_callback(VerifyCallback callback)
> {
> boost::system::error_code ec;
> this->set_verify_callback(callback, ec);
> boost::asio::detail::throw_error(ec, "set_verify_callback");
> }
># 352 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename VerifyCallback>
> boost::system::error_code set_verify_callback(VerifyCallback callback,
> boost::system::error_code& ec)
> {
> core_.engine_.set_verify_callback(
> new detail::verify_callback<VerifyCallback>(callback), ec);
> return ec;
> }
># 371 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> void handshake(handshake_type type)
> {
> boost::system::error_code ec;
> handshake(type, ec);
> boost::asio::detail::throw_error(ec, "handshake");
> }
># 388 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> boost::system::error_code handshake(handshake_type type,
> boost::system::error_code& ec)
> {
> detail::io(next_layer_, core_, detail::handshake_op(type), ec);
> return ec;
> }
># 407 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ConstBufferSequence>
> void handshake(handshake_type type, const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> handshake(type, buffers, ec);
> boost::asio::detail::throw_error(ec, "handshake");
> }
># 427 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ConstBufferSequence>
> boost::system::error_code handshake(handshake_type type,
> const ConstBufferSequence& buffers, boost::system::error_code& ec)
> {
> detail::io(next_layer_, core_,
> detail::buffered_handshake_op<ConstBufferSequence>(type, buffers), ec);
> return ec;
> }
># 451 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename HandshakeHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<HandshakeHandler>::type, void (boost::system::error_code)>::return_type
>
> async_handshake(handshake_type type,
> HandshakeHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<HandshakeHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "HandshakeHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
> boost::asio::async_completion<HandshakeHandler,
> void (boost::system::error_code)> init(handler);
>
> detail::async_io(next_layer_, core_,
> detail::handshake_op(type), init.completion_handler);
>
> return init.result.get();
> }
># 491 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ConstBufferSequence, typename BufferedHandshakeHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<BufferedHandshakeHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_handshake(handshake_type type, const ConstBufferSequence& buffers,
> BufferedHandshakeHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<BufferedHandshakeHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "BufferedHandshakeHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__))
> type_check;
>
> boost::asio::async_completion<BufferedHandshakeHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::async_io(next_layer_, core_,
> detail::buffered_handshake_op<ConstBufferSequence>(type, buffers),
> init.completion_handler);
>
> return init.result.get();
> }
># 519 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> void shutdown()
> {
> boost::system::error_code ec;
> shutdown(ec);
> boost::asio::detail::throw_error(ec, "shutdown");
> }
># 533 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> boost::system::error_code shutdown(boost::system::error_code& ec)
> {
> detail::io(next_layer_, core_, detail::shutdown_op(), ec);
> return ec;
> }
># 551 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ShutdownHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ShutdownHandler>::type, void (boost::system::error_code)>::return_type
>
> async_shutdown(ShutdownHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ShutdownHandler>::type, void(boost::system::error_code)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::one_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0))) == 1, "ShutdownHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>()), char(0))> __attribute__((__unused__)) type_check;
>
> boost::asio::async_completion<ShutdownHandler,
> void (boost::system::error_code)> init(handler);
>
> detail::async_io(next_layer_, core_, detail::shutdown_op(),
> init.completion_handler);
>
> return init.result.get();
> }
># 585 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t n = write_some(buffers, ec);
> boost::asio::detail::throw_error(ec, "write_some");
> return n;
> }
># 610 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ConstBufferSequence>
> std::size_t write_some(const ConstBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return detail::io(next_layer_, core_,
> detail::write_op<ConstBufferSequence>(buffers), ec);
> }
># 640 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename ConstBufferSequence, typename WriteHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_write_some(const ConstBufferSequence& buffers,
> WriteHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<WriteHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "WriteHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> boost::asio::async_completion<WriteHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::async_io(next_layer_, core_,
> detail::write_op<ConstBufferSequence>(buffers),
> init.completion_handler);
>
> return init.result.get();
> }
># 676 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers)
> {
> boost::system::error_code ec;
> std::size_t n = read_some(buffers, ec);
> boost::asio::detail::throw_error(ec, "read_some");
> return n;
> }
># 701 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename MutableBufferSequence>
> std::size_t read_some(const MutableBufferSequence& buffers,
> boost::system::error_code& ec)
> {
> return detail::io(next_layer_, core_,
> detail::read_op<MutableBufferSequence>(buffers), ec);
> }
># 732 "/usr/include/boost/asio/ssl/stream.hpp" 3 4
> template <typename MutableBufferSequence, typename ReadHandler>
> typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void (boost::system::error_code, std::size_t)>::return_type
>
> async_read_some(const MutableBufferSequence& buffers,
> ReadHandler&& handler)
> {
>
>
> typedef typename ::boost::asio::async_result< typename ::boost::asio::decay<ReadHandler>::type, void(boost::system::error_code, std::size_t)>::completion_handler_type asio_true_handler_type; static_assert(sizeof(boost::asio::detail::two_arg_handler_test( boost::asio::detail::rvref< asio_true_handler_type>(), static_cast<const boost::system::error_code*>(0), static_cast<const std::size_t*>(0))) == 1, "ReadHandler type requirements not met"); typedef boost::asio::detail::handler_type_requirements< sizeof( boost::asio::detail::argbyv( boost::asio::detail::rvref< asio_true_handler_type>())) + sizeof( boost::asio::detail::lvref< asio_true_handler_type>()( boost::asio::detail::lvref<const boost::system::error_code>(), boost::asio::detail::lvref<const std::size_t>()), char(0))> __attribute__((__unused__)) type_check;
>
> boost::asio::async_completion<ReadHandler,
> void (boost::system::error_code, std::size_t)> init(handler);
>
> detail::async_io(next_layer_, core_,
> detail::read_op<MutableBufferSequence>(buffers),
> init.completion_handler);
>
> return init.result.get();
> }
>
>private:
> Stream next_layer_;
> detail::stream_core core_;
>};
>
>}
>}
>}
>
># 1 "/usr/include/boost/asio/detail/pop_options.hpp" 1 3 4
># 67 "/usr/include/boost/asio/detail/pop_options.hpp" 3 4
>#pragma GCC visibility pop
>
>
>
>#pragma GCC diagnostic pop
># 762 "/usr/include/boost/asio/ssl/stream.hpp" 2 3 4
># 23 "/usr/include/boost/asio/ssl.hpp" 2 3 4
># 38 "/usr/local/include/nghttp2/asio_http2.h" 2 3
>
># 1 "/usr/local/include/nghttp2/nghttp2.h" 1 3
># 35 "/usr/local/include/nghttp2/nghttp2.h" 3
>extern "C" {
>
>
># 1 "/usr/include/c++/8/stdlib.h" 1 3
># 39 "/usr/local/include/nghttp2/nghttp2.h" 2 3
>
>
>
>
>
>
># 1 "/usr/include/inttypes.h" 1 3 4
># 266 "/usr/include/inttypes.h" 3 4
>extern "C" {
>
>
>
>
>typedef struct
> {
> long int quot;
> long int rem;
> } imaxdiv_t;
># 290 "/usr/include/inttypes.h" 3 4
>extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));
>
>
>extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
> throw () __attribute__ ((__const__));
>
>
>extern intmax_t strtoimax (const char *__restrict __nptr,
> char **__restrict __endptr, int __base) throw ();
>
>
>extern uintmax_t strtoumax (const char *__restrict __nptr,
> char ** __restrict __endptr, int __base) throw ();
>
>
>extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
> wchar_t **__restrict __endptr, int __base)
> throw ();
>
>
>extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
> wchar_t ** __restrict __endptr, int __base)
> throw ();
>
>
>
>
>
>extern long int __strtol_internal (const char *__restrict __nptr,
> char **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) intmax_t
>__attribute__ ((__leaf__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()
>
>{
> return __strtol_internal (nptr, endptr, base, 0);
>}
>
>extern unsigned long int __strtoul_internal (const char *__restrict __nptr,
> char ** __restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
>__attribute__ ((__leaf__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()
>
>{
> return __strtoul_internal (nptr, endptr, base, 0);
>}
>
>extern long int __wcstol_internal (const wchar_t * __restrict __nptr,
> wchar_t **__restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) intmax_t
>__attribute__ ((__leaf__)) wcstoimax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()
>
>{
> return __wcstol_internal (nptr, endptr, base, 0);
>}
>
>extern unsigned long int __wcstoul_internal (const wchar_t *
> __restrict __nptr,
> wchar_t **
> __restrict __endptr,
> int __base, int __group)
> throw () __attribute__ ((__nonnull__ (1))) ;
>
>extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
>__attribute__ ((__leaf__)) wcstoumax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()
>
>{
> return __wcstoul_internal (nptr, endptr, base, 0);
>}
># 432 "/usr/include/inttypes.h" 3 4
>}
># 46 "/usr/local/include/nghttp2/nghttp2.h" 2 3
>
>
>
>
># 1 "/usr/local/include/nghttp2/nghttp2ver.h" 1 3
># 51 "/usr/local/include/nghttp2/nghttp2.h" 2 3
># 116 "/usr/local/include/nghttp2/nghttp2.h" 3
>struct nghttp2_session;
>
>
>
>
>
>
>
>typedef struct nghttp2_session nghttp2_session;
># 139 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef struct {
>
>
>
>
>
> int age;
>
>
>
> int version_num;
>
>
>
> const char *version_str;
>
>
>
>
> const char *proto_str;
>
>} nghttp2_info;
># 231 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef enum {
>
>
>
> NGHTTP2_ERR_INVALID_ARGUMENT = -501,
>
>
>
> NGHTTP2_ERR_BUFFER_ERROR = -502,
>
>
>
> NGHTTP2_ERR_UNSUPPORTED_VERSION = -503,
>
>
>
>
>
>
> NGHTTP2_ERR_WOULDBLOCK = -504,
>
>
>
> NGHTTP2_ERR_PROTO = -505,
>
>
>
> NGHTTP2_ERR_INVALID_FRAME = -506,
>
>
>
> NGHTTP2_ERR_EOF = -507,
>
>
>
>
>
>
> NGHTTP2_ERR_DEFERRED = -508,
>
>
>
>
> NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE = -509,
>
>
>
> NGHTTP2_ERR_STREAM_CLOSED = -510,
>
>
>
>
> NGHTTP2_ERR_STREAM_CLOSING = -511,
>
>
>
>
> NGHTTP2_ERR_STREAM_SHUT_WR = -512,
>
>
>
> NGHTTP2_ERR_INVALID_STREAM_ID = -513,
>
>
>
>
> NGHTTP2_ERR_INVALID_STREAM_STATE = -514,
>
>
>
> NGHTTP2_ERR_DEFERRED_DATA_EXIST = -515,
>
>
>
>
> NGHTTP2_ERR_START_STREAM_NOT_ALLOWED = -516,
>
>
>
> NGHTTP2_ERR_GOAWAY_ALREADY_SENT = -517,
>
>
>
>
>
>
>
> NGHTTP2_ERR_INVALID_HEADER_BLOCK = -518,
>
>
>
>
> NGHTTP2_ERR_INVALID_STATE = -519,
>
>
>
> NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE = -521,
>
>
>
> NGHTTP2_ERR_FRAME_SIZE_ERROR = -522,
>
>
>
> NGHTTP2_ERR_HEADER_COMP = -523,
>
>
>
> NGHTTP2_ERR_FLOW_CONTROL = -524,
>
>
>
> NGHTTP2_ERR_INSUFF_BUFSIZE = -525,
>
>
>
> NGHTTP2_ERR_PAUSE = -526,
>
>
>
>
> NGHTTP2_ERR_TOO_MANY_INFLIGHT_SETTINGS = -527,
>
>
>
> NGHTTP2_ERR_PUSH_DISABLED = -528,
>
>
>
>
>
>
> NGHTTP2_ERR_DATA_EXIST = -529,
>
>
>
>
> NGHTTP2_ERR_SESSION_CLOSING = -530,
>
>
>
>
> NGHTTP2_ERR_HTTP_HEADER = -531,
>
>
>
> NGHTTP2_ERR_HTTP_MESSAGING = -532,
>
>
>
> NGHTTP2_ERR_REFUSED_STREAM = -533,
>
>
>
> NGHTTP2_ERR_INTERNAL = -534,
>
>
>
> NGHTTP2_ERR_CANCEL = -535,
>
>
>
>
> NGHTTP2_ERR_SETTINGS_EXPECTED = -536,
># 403 "/usr/local/include/nghttp2/nghttp2.h" 3
> NGHTTP2_ERR_FATAL = -900,
>
>
>
> NGHTTP2_ERR_NOMEM = -901,
>
>
>
> NGHTTP2_ERR_CALLBACK_FAILURE = -902,
>
>
>
>
> NGHTTP2_ERR_BAD_CLIENT_MAGIC = -903,
># 425 "/usr/local/include/nghttp2/nghttp2.h" 3
> NGHTTP2_ERR_FLOODED = -904
>} nghttp2_error;
>
>
>
>
>
>
>typedef struct {
>
>
>
> uint8_t *base;
>
>
>
> size_t len;
>} nghttp2_vec;
>
>struct nghttp2_rcbuf;
>
>
>
>
>
>
>
>typedef struct nghttp2_rcbuf nghttp2_rcbuf;
>
>
>
>
>
>
> void nghttp2_rcbuf_incref(nghttp2_rcbuf *rcbuf);
># 468 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_rcbuf_decref(nghttp2_rcbuf *rcbuf);
>
>
>
>
>
>
> nghttp2_vec nghttp2_rcbuf_get_buf(nghttp2_rcbuf *rcbuf);
># 484 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_rcbuf_is_static(const nghttp2_rcbuf *rcbuf);
>
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_NV_FLAG_NONE = 0,
>
>
>
>
>
> NGHTTP2_NV_FLAG_NO_INDEX = 0x01,
>
>
>
>
>
> NGHTTP2_NV_FLAG_NO_COPY_NAME = 0x02,
>
>
>
>
>
> NGHTTP2_NV_FLAG_NO_COPY_VALUE = 0x04
>} nghttp2_nv_flag;
>
>
>
>
>
>
>typedef struct {
># 534 "/usr/local/include/nghttp2/nghttp2.h" 3
> uint8_t *name;
># 547 "/usr/local/include/nghttp2/nghttp2.h" 3
> uint8_t *value;
>
>
>
> size_t namelen;
>
>
>
> size_t valuelen;
>
>
>
> uint8_t flags;
>} nghttp2_nv;
>
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_DATA = 0,
>
>
>
> NGHTTP2_HEADERS = 0x01,
>
>
>
> NGHTTP2_PRIORITY = 0x02,
>
>
>
> NGHTTP2_RST_STREAM = 0x03,
>
>
>
> NGHTTP2_SETTINGS = 0x04,
>
>
>
> NGHTTP2_PUSH_PROMISE = 0x05,
>
>
>
> NGHTTP2_PING = 0x06,
>
>
>
> NGHTTP2_GOAWAY = 0x07,
>
>
>
> NGHTTP2_WINDOW_UPDATE = 0x08,
>
>
>
>
>
> NGHTTP2_CONTINUATION = 0x09,
>
>
>
>
> NGHTTP2_ALTSVC = 0x0a,
>
>
>
>
> NGHTTP2_ORIGIN = 0x0c
>} nghttp2_frame_type;
>
>
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_FLAG_NONE = 0,
>
>
>
> NGHTTP2_FLAG_END_STREAM = 0x01,
>
>
>
> NGHTTP2_FLAG_END_HEADERS = 0x04,
>
>
>
> NGHTTP2_FLAG_ACK = 0x01,
>
>
>
> NGHTTP2_FLAG_PADDED = 0x08,
>
>
>
> NGHTTP2_FLAG_PRIORITY = 0x20
>} nghttp2_flag;
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_SETTINGS_HEADER_TABLE_SIZE = 0x01,
>
>
>
> NGHTTP2_SETTINGS_ENABLE_PUSH = 0x02,
>
>
>
> NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS = 0x03,
>
>
>
> NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE = 0x04,
>
>
>
> NGHTTP2_SETTINGS_MAX_FRAME_SIZE = 0x05,
>
>
>
> NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE = 0x06
>} nghttp2_settings_id;
># 711 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef enum {
>
>
>
> NGHTTP2_NO_ERROR = 0x00,
>
>
>
> NGHTTP2_PROTOCOL_ERROR = 0x01,
>
>
>
> NGHTTP2_INTERNAL_ERROR = 0x02,
>
>
>
> NGHTTP2_FLOW_CONTROL_ERROR = 0x03,
>
>
>
> NGHTTP2_SETTINGS_TIMEOUT = 0x04,
>
>
>
> NGHTTP2_STREAM_CLOSED = 0x05,
>
>
>
> NGHTTP2_FRAME_SIZE_ERROR = 0x06,
>
>
>
> NGHTTP2_REFUSED_STREAM = 0x07,
>
>
>
> NGHTTP2_CANCEL = 0x08,
>
>
>
> NGHTTP2_COMPRESSION_ERROR = 0x09,
>
>
>
> NGHTTP2_CONNECT_ERROR = 0x0a,
>
>
>
> NGHTTP2_ENHANCE_YOUR_CALM = 0x0b,
>
>
>
> NGHTTP2_INADEQUATE_SECURITY = 0x0c,
>
>
>
> NGHTTP2_HTTP_1_1_REQUIRED = 0x0d
>} nghttp2_error_code;
>
>
>
>
>
>typedef struct {
>
>
>
> size_t length;
>
>
>
> int32_t stream_id;
>
>
>
> uint8_t type;
>
>
>
> uint8_t flags;
>
>
>
>
> uint8_t reserved;
>} nghttp2_frame_hd;
>
>
>
>
>
>
>
>typedef union {
>
>
>
> int fd;
>
>
>
> void *ptr;
>} nghttp2_data_source;
>
>
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_DATA_FLAG_NONE = 0,
>
>
>
> NGHTTP2_DATA_FLAG_EOF = 0x01,
>
>
>
>
>
>
> NGHTTP2_DATA_FLAG_NO_END_STREAM = 0x02,
>
>
>
>
> NGHTTP2_DATA_FLAG_NO_COPY = 0x04
>} nghttp2_data_flag;
># 903 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef ssize_t (*nghttp2_data_source_read_callback)(
> nghttp2_session *session, int32_t stream_id, uint8_t *buf, size_t length,
> uint32_t *data_flags, nghttp2_data_source *source, void *user_data);
>
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_data_source source;
>
>
>
> nghttp2_data_source_read_callback read_callback;
>} nghttp2_data_provider;
>
>
>
>
>
>
>
>typedef struct {
> nghttp2_frame_hd hd;
>
>
>
>
> size_t padlen;
>} nghttp2_data;
># 948 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef enum {
>
>
>
>
> NGHTTP2_HCAT_REQUEST = 0,
>
>
>
>
> NGHTTP2_HCAT_RESPONSE = 1,
>
>
>
>
> NGHTTP2_HCAT_PUSH_RESPONSE = 2,
>
>
>
>
>
>
> NGHTTP2_HCAT_HEADERS = 3
>} nghttp2_headers_category;
>
>
>
>
>
>
>typedef struct {
>
>
>
>
> int32_t stream_id;
>
>
>
> int32_t weight;
>
>
>
> uint8_t exclusive;
>} nghttp2_priority_spec;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
>
> size_t padlen;
>
>
>
> nghttp2_priority_spec pri_spec;
>
>
>
> nghttp2_nv *nva;
>
>
>
> size_t nvlen;
>
>
>
> nghttp2_headers_category cat;
>} nghttp2_headers;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> nghttp2_priority_spec pri_spec;
>} nghttp2_priority;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> uint32_t error_code;
>} nghttp2_rst_stream;
>
>
>
>
>
>
>typedef struct {
>
>
>
> int32_t settings_id;
>
>
>
> uint32_t value;
>} nghttp2_settings_entry;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> size_t niv;
>
>
>
> nghttp2_settings_entry *iv;
>} nghttp2_settings;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
>
> size_t padlen;
>
>
>
> nghttp2_nv *nva;
>
>
>
> size_t nvlen;
>
>
>
> int32_t promised_stream_id;
>
>
>
>
> uint8_t reserved;
>} nghttp2_push_promise;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> uint8_t opaque_data[8];
>} nghttp2_ping;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> int32_t last_stream_id;
>
>
>
> uint32_t error_code;
>
>
>
> uint8_t *opaque_data;
>
>
>
> size_t opaque_data_len;
>
>
>
>
> uint8_t reserved;
>} nghttp2_goaway;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> int32_t window_size_increment;
>
>
>
>
> uint8_t reserved;
>} nghttp2_window_update;
>
>
>
>
>
>
>typedef struct {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
>
>
>
>
> void *payload;
>} nghttp2_extension;
># 1226 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef union {
>
>
>
> nghttp2_frame_hd hd;
>
>
>
> nghttp2_data data;
>
>
>
> nghttp2_headers headers;
>
>
>
> nghttp2_priority priority;
>
>
>
> nghttp2_rst_stream rst_stream;
>
>
>
> nghttp2_settings settings;
>
>
>
> nghttp2_push_promise push_promise;
>
>
>
> nghttp2_ping ping;
>
>
>
> nghttp2_goaway goaway;
>
>
>
> nghttp2_window_update window_update;
>
>
>
> nghttp2_extension ext;
>} nghttp2_frame;
># 1303 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef ssize_t (*nghttp2_send_callback)(nghttp2_session *session,
> const uint8_t *data, size_t length,
> int flags, void *user_data);
># 1346 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_send_data_callback)(nghttp2_session *session,
> nghttp2_frame *frame,
> const uint8_t *framehd, size_t length,
> nghttp2_data_source *source,
> void *user_data);
># 1376 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef ssize_t (*nghttp2_recv_callback)(nghttp2_session *session, uint8_t *buf,
> size_t length, int flags,
> void *user_data);
># 1414 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_frame_recv_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> void *user_data);
># 1442 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_invalid_frame_recv_callback)(
> nghttp2_session *session, const nghttp2_frame *frame, int lib_error_code,
> void *user_data);
># 1476 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_data_chunk_recv_callback)(nghttp2_session *session,
> uint8_t flags,
> int32_t stream_id,
> const uint8_t *data,
> size_t len, void *user_data);
># 1508 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_before_frame_send_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> void *user_data);
># 1527 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_frame_send_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> void *user_data);
># 1552 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_frame_not_send_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> int lib_error_code,
> void *user_data);
># 1580 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_stream_close_callback)(nghttp2_session *session,
> int32_t stream_id,
> uint32_t error_code,
> void *user_data);
># 1643 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_begin_headers_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> void *user_data);
># 1722 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_header_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> const uint8_t *name, size_t namelen,
> const uint8_t *value, size_t valuelen,
> uint8_t flags, void *user_data);
># 1748 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_header_callback2)(nghttp2_session *session,
> const nghttp2_frame *frame,
> nghttp2_rcbuf *name,
> nghttp2_rcbuf *value, uint8_t flags,
> void *user_data);
># 1785 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_invalid_header_callback)(
> nghttp2_session *session, const nghttp2_frame *frame, const uint8_t *name,
> size_t namelen, const uint8_t *value, size_t valuelen, uint8_t flags,
> void *user_data);
># 1817 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_invalid_header_callback2)(
> nghttp2_session *session, const nghttp2_frame *frame, nghttp2_rcbuf *name,
> nghttp2_rcbuf *value, uint8_t flags, void *user_data);
># 1838 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef ssize_t (*nghttp2_select_padding_callback)(nghttp2_session *session,
> const nghttp2_frame *frame,
> size_t max_payloadlen,
> void *user_data);
># 1867 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef ssize_t (*nghttp2_data_source_read_length_callback)(
> nghttp2_session *session, uint8_t frame_type, int32_t stream_id,
> int32_t session_remote_window_size, int32_t stream_remote_window_size,
> uint32_t remote_max_frame_size, void *user_data);
># 1894 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_begin_frame_callback)(nghttp2_session *session,
> const nghttp2_frame_hd *hd,
> void *user_data);
># 1917 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_on_extension_chunk_recv_callback)(
> nghttp2_session *session, const nghttp2_frame_hd *hd, const uint8_t *data,
> size_t len, void *user_data);
># 1954 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_unpack_extension_callback)(nghttp2_session *session,
> void **payload,
> const nghttp2_frame_hd *hd,
> void *user_data);
># 1986 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef ssize_t (*nghttp2_pack_extension_callback)(nghttp2_session *session,
> uint8_t *buf, size_t len,
> const nghttp2_frame *frame,
> void *user_data);
># 2016 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_error_callback)(nghttp2_session *session, const char *msg,
> size_t len, void *user_data);
># 2042 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef int (*nghttp2_error_callback2)(nghttp2_session *session,
> int lib_error_code, const char *msg,
> size_t len, void *user_data);
>
>struct nghttp2_session_callbacks;
>
>
>
>
>
>
>
>typedef struct nghttp2_session_callbacks nghttp2_session_callbacks;
># 2073 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_callbacks_new(nghttp2_session_callbacks **callbacks_ptr);
>
>
>
>
>
>
>
> void
>nghttp2_session_callbacks_del(nghttp2_session_callbacks *callbacks);
># 2093 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_send_callback(
> nghttp2_session_callbacks *cbs, nghttp2_send_callback send_callback);
># 2104 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_recv_callback(
> nghttp2_session_callbacks *cbs, nghttp2_recv_callback recv_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_frame_recv_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_frame_recv_callback on_frame_recv_callback);
># 2124 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_session_callbacks_set_on_invalid_frame_recv_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_invalid_frame_recv_callback on_invalid_frame_recv_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_data_chunk_recv_callback on_data_chunk_recv_callback);
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_before_frame_send_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_before_frame_send_callback before_frame_send_callback);
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_frame_send_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_frame_send_callback on_frame_send_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_frame_not_send_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_frame_not_send_callback on_frame_not_send_callback);
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_stream_close_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_stream_close_callback on_stream_close_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_begin_headers_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_begin_headers_callback on_begin_headers_callback);
># 2195 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_on_header_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_header_callback on_header_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_header_callback2(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_header_callback2 on_header_callback2);
># 2218 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_on_invalid_header_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_invalid_header_callback on_invalid_header_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_invalid_header_callback2(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_invalid_header_callback2 on_invalid_header_callback2);
># 2239 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_select_padding_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_select_padding_callback select_padding_callback);
>
>
>
>
>
>
>
> void
>nghttp2_session_callbacks_set_data_source_read_length_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_data_source_read_length_callback data_source_read_length_callback);
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_on_begin_frame_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_begin_frame_callback on_begin_frame_callback);
># 2270 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_send_data_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_send_data_callback send_data_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_pack_extension_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_pack_extension_callback pack_extension_callback);
>
>
>
>
>
>
>
> void nghttp2_session_callbacks_set_unpack_extension_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_unpack_extension_callback unpack_extension_callback);
>
>
>
>
>
>
>
> void
>nghttp2_session_callbacks_set_on_extension_chunk_recv_callback(
> nghttp2_session_callbacks *cbs,
> nghttp2_on_extension_chunk_recv_callback on_extension_chunk_recv_callback);
># 2318 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_error_callback(
> nghttp2_session_callbacks *cbs, nghttp2_error_callback error_callback);
># 2331 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_callbacks_set_error_callback2(
> nghttp2_session_callbacks *cbs, nghttp2_error_callback2 error_callback2);
>
>
>
>
>
>
>
>typedef void *(*nghttp2_malloc)(size_t size, void *mem_user_data);
>
>
>
>
>
>
>
>typedef void (*nghttp2_free)(void *ptr, void *mem_user_data);
>
>
>
>
>
>
>
>typedef void *(*nghttp2_calloc)(size_t nmemb, size_t size, void *mem_user_data);
>
>
>
>
>
>
>
>typedef void *(*nghttp2_realloc)(void *ptr, size_t size, void *mem_user_data);
># 2405 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef struct {
>
>
>
>
> void *mem_user_data;
>
>
>
> nghttp2_malloc malloc;
>
>
>
> nghttp2_free free;
>
>
>
> nghttp2_calloc calloc;
>
>
>
> nghttp2_realloc realloc;
>} nghttp2_mem;
>
>struct nghttp2_option;
>
>
>
>
>
>
>
>typedef struct nghttp2_option nghttp2_option;
># 2453 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_option_new(nghttp2_option **option_ptr);
>
>
>
>
>
>
>
> void nghttp2_option_del(nghttp2_option *option);
># 2473 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_no_auto_window_update(nghttp2_option *option, int val);
># 2491 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_peer_max_concurrent_streams(nghttp2_option *option,
> uint32_t val);
># 2513 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_no_recv_client_magic(nghttp2_option *option, int val);
># 2529 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_option_set_no_http_messaging(nghttp2_option *option,
> int val);
># 2547 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_max_reserved_remote_streams(nghttp2_option *option,
> uint32_t val);
># 2564 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_user_recv_extension_type(nghttp2_option *option,
> uint8_t type);
># 2584 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_builtin_recv_extension_type(nghttp2_option *option,
> uint8_t type);
># 2599 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_option_set_no_auto_ping_ack(nghttp2_option *option,
> int val);
># 2613 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_max_send_header_block_length(nghttp2_option *option,
> size_t val);
># 2626 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_option_set_max_deflate_dynamic_table_size(nghttp2_option *option,
> size_t val);
># 2637 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_option_set_no_closed_streams(nghttp2_option *option,
> int val);
># 2661 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_client_new(nghttp2_session **session_ptr,
> const nghttp2_session_callbacks *callbacks,
> void *user_data);
># 2687 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_server_new(nghttp2_session **session_ptr,
> const nghttp2_session_callbacks *callbacks,
> void *user_data);
># 2713 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_client_new2(nghttp2_session **session_ptr,
> const nghttp2_session_callbacks *callbacks,
> void *user_data, const nghttp2_option *option);
># 2739 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_server_new2(nghttp2_session **session_ptr,
> const nghttp2_session_callbacks *callbacks,
> void *user_data, const nghttp2_option *option);
># 2765 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_client_new3(
> nghttp2_session **session_ptr, const nghttp2_session_callbacks *callbacks,
> void *user_data, const nghttp2_option *option, nghttp2_mem *mem);
># 2790 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_server_new3(
> nghttp2_session **session_ptr, const nghttp2_session_callbacks *callbacks,
> void *user_data, const nghttp2_option *option, nghttp2_mem *mem);
>
>
>
>
>
>
>
> void nghttp2_session_del(nghttp2_session *session);
># 2855 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_send(nghttp2_session *session);
># 2896 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_session_mem_send(nghttp2_session *session,
> const uint8_t **data_ptr);
># 2967 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_recv(nghttp2_session *session);
># 3006 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_session_mem_recv(nghttp2_session *session,
> const uint8_t *in,
> size_t inlen);
># 3024 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_resume_data(nghttp2_session *session,
> int32_t stream_id);
># 3037 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_want_read(nghttp2_session *session);
># 3049 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_want_write(nghttp2_session *session);
># 3063 "/usr/local/include/nghttp2/nghttp2.h" 3
> void *
>nghttp2_session_get_stream_user_data(nghttp2_session *session,
> int32_t stream_id);
># 3085 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_set_stream_user_data(nghttp2_session *session,
> int32_t stream_id, void *stream_user_data);
># 3096 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_session_set_user_data(nghttp2_session *session,
> void *user_data);
>
>
>
>
>
>
>
> size_t
>nghttp2_session_get_outbound_queue_size(nghttp2_session *session);
># 3122 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_session_get_stream_effective_recv_data_length(
> nghttp2_session *session, int32_t stream_id);
># 3142 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_session_get_stream_effective_local_window_size(
> nghttp2_session *session, int32_t stream_id);
># 3157 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_session_get_stream_local_window_size(
> nghttp2_session *session, int32_t stream_id);
># 3174 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t
>nghttp2_session_get_effective_recv_data_length(nghttp2_session *session);
># 3194 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t
>nghttp2_session_get_effective_local_window_size(nghttp2_session *session);
># 3208 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t
>nghttp2_session_get_local_window_size(nghttp2_session *session);
># 3225 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_session_get_stream_remote_window_size(
> nghttp2_session *session, int32_t stream_id);
># 3235 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t
>nghttp2_session_get_remote_window_size(nghttp2_session *session);
>
>
>
>
>
>
>
> int
>nghttp2_session_get_stream_local_close(nghttp2_session *session,
> int32_t stream_id);
>
>
>
>
>
>
>
> int
>nghttp2_session_get_stream_remote_close(nghttp2_session *session,
> int32_t stream_id);
>
>
>
>
>
>
>
> size_t
>nghttp2_session_get_hd_inflate_dynamic_table_size(nghttp2_session *session);
>
>
>
>
>
>
>
> size_t
>nghttp2_session_get_hd_deflate_dynamic_table_size(nghttp2_session *session);
># 3302 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_terminate_session(nghttp2_session *session,
> uint32_t error_code);
># 3331 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_terminate_session2(nghttp2_session *session,
> int32_t last_stream_id,
> uint32_t error_code);
># 3370 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_shutdown_notice(nghttp2_session *session);
># 3379 "/usr/local/include/nghttp2/nghttp2.h" 3
> uint32_t nghttp2_session_get_remote_settings(
> nghttp2_session *session, nghttp2_settings_id id);
># 3389 "/usr/local/include/nghttp2/nghttp2.h" 3
> uint32_t nghttp2_session_get_local_settings(
> nghttp2_session *session, nghttp2_settings_id id);
># 3408 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_set_next_stream_id(nghttp2_session *session,
> int32_t next_stream_id);
># 3418 "/usr/local/include/nghttp2/nghttp2.h" 3
> uint32_t
>nghttp2_session_get_next_stream_id(nghttp2_session *session);
># 3444 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_consume(nghttp2_session *session,
> int32_t stream_id, size_t size);
># 3463 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_consume_connection(nghttp2_session *session,
> size_t size);
># 3484 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_consume_stream(nghttp2_session *session,
> int32_t stream_id,
> size_t size);
># 3517 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_change_stream_priority(nghttp2_session *session,
> int32_t stream_id,
> const nghttp2_priority_spec *pri_spec);
># 3563 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_create_idle_stream(nghttp2_session *session, int32_t stream_id,
> const nghttp2_priority_spec *pri_spec);
># 3614 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_upgrade(nghttp2_session *session,
> const uint8_t *settings_payload,
> size_t settings_payloadlen,
> void *stream_user_data);
># 3658 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_session_upgrade2(nghttp2_session *session,
> const uint8_t *settings_payload,
> size_t settings_payloadlen,
> int head_request,
> void *stream_user_data);
># 3685 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_pack_settings_payload(
> uint8_t *buf, size_t buflen, const nghttp2_settings_entry *iv, size_t niv);
>
>
>
>
>
>
>
> const char *nghttp2_strerror(int lib_error_code);
># 3704 "/usr/local/include/nghttp2/nghttp2.h" 3
> const char *nghttp2_http2_strerror(uint32_t error_code);
># 3716 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_priority_spec_init(nghttp2_priority_spec *pri_spec,
> int32_t stream_id,
> int32_t weight, int exclusive);
># 3727 "/usr/local/include/nghttp2/nghttp2.h" 3
> void
>nghttp2_priority_spec_default_init(nghttp2_priority_spec *pri_spec);
>
>
>
>
>
>
> int
>nghttp2_priority_spec_check_default(const nghttp2_priority_spec *pri_spec);
># 3811 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_submit_request(
> nghttp2_session *session, const nghttp2_priority_spec *pri_spec,
> const nghttp2_nv *nva, size_t nvlen, const nghttp2_data_provider *data_prd,
> void *stream_user_data);
># 3880 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_submit_response(nghttp2_session *session, int32_t stream_id,
> const nghttp2_nv *nva, size_t nvlen,
> const nghttp2_data_provider *data_prd);
># 3936 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_trailer(nghttp2_session *session,
> int32_t stream_id,
> const nghttp2_nv *nva, size_t nvlen);
># 4028 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_submit_headers(
> nghttp2_session *session, uint8_t flags, int32_t stream_id,
> const nghttp2_priority_spec *pri_spec, const nghttp2_nv *nva, size_t nvlen,
> void *stream_user_data);
># 4073 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_data(nghttp2_session *session, uint8_t flags,
> int32_t stream_id,
> const nghttp2_data_provider *data_prd);
># 4106 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_submit_priority(nghttp2_session *session, uint8_t flags,
> int32_t stream_id,
> const nghttp2_priority_spec *pri_spec);
># 4130 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_rst_stream(nghttp2_session *session,
> uint8_t flags, int32_t stream_id,
> uint32_t error_code);
># 4163 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_settings(nghttp2_session *session,
> uint8_t flags,
> const nghttp2_settings_entry *iv,
> size_t niv);
># 4239 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t nghttp2_submit_push_promise(
> nghttp2_session *session, uint8_t flags, int32_t stream_id,
> const nghttp2_nv *nva, size_t nvlen, void *promised_stream_user_data);
># 4268 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_ping(nghttp2_session *session, uint8_t flags,
> const uint8_t *opaque_data);
># 4316 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_goaway(nghttp2_session *session,
> uint8_t flags, int32_t last_stream_id,
> uint32_t error_code,
> const uint8_t *opaque_data,
> size_t opaque_data_len);
># 4333 "/usr/local/include/nghttp2/nghttp2.h" 3
> int32_t
>nghttp2_session_get_last_proc_stream_id(nghttp2_session *session);
># 4351 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_check_request_allowed(nghttp2_session *session);
>
>
>
>
>
>
> int
>nghttp2_session_check_server_session(nghttp2_session *session);
># 4400 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_window_update(nghttp2_session *session,
> uint8_t flags,
> int32_t stream_id,
> int32_t window_size_increment);
># 4439 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_session_set_local_window_size(nghttp2_session *session, uint8_t flags,
> int32_t stream_id, int32_t window_size);
># 4481 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_extension(nghttp2_session *session,
> uint8_t type, uint8_t flags,
> int32_t stream_id, void *payload);
># 4497 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef struct {
>
>
>
>
> uint8_t *origin;
>
>
>
> size_t origin_len;
>
>
>
>
> uint8_t *field_value;
>
>
>
> size_t field_value_len;
>} nghttp2_ext_altsvc;
># 4551 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_altsvc(nghttp2_session *session,
> uint8_t flags, int32_t stream_id,
> const uint8_t *origin,
> size_t origin_len,
> const uint8_t *field_value,
> size_t field_value_len);
>
>
>
>
>
>
>typedef struct {
>
>
>
>
> uint8_t *origin;
>
>
>
> size_t origin_len;
>} nghttp2_origin_entry;
># 4590 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef struct {
>
>
>
> size_t nov;
>
>
>
> nghttp2_origin_entry *ov;
>} nghttp2_ext_origin;
># 4627 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_submit_origin(nghttp2_session *session,
> uint8_t flags,
> const nghttp2_origin_entry *ov,
> size_t nov);
># 4641 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_nv_compare_name(const nghttp2_nv *lhs,
> const nghttp2_nv *rhs);
># 4702 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_select_next_protocol(unsigned char **out,
> unsigned char *outlen,
> const unsigned char *in,
> unsigned int inlen);
># 4716 "/usr/local/include/nghttp2/nghttp2.h" 3
> nghttp2_info *nghttp2_version(int least_version);
>
>
>
>
>
>
>
> int nghttp2_is_fatal(int lib_error_code);
># 4735 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_check_header_name(const uint8_t *name, size_t len);
># 4744 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_check_header_value(const uint8_t *value, size_t len);
>
>
>
>struct nghttp2_hd_deflater;
>
>
>
>
>
>
>typedef struct nghttp2_hd_deflater nghttp2_hd_deflater;
># 4773 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_hd_deflate_new(nghttp2_hd_deflater **deflater_ptr,
> size_t max_deflate_dynamic_table_size);
># 4792 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_hd_deflate_new2(nghttp2_hd_deflater **deflater_ptr,
> size_t max_deflate_dynamic_table_size,
> nghttp2_mem *mem);
>
>
>
>
>
>
> void nghttp2_hd_deflate_del(nghttp2_hd_deflater *deflater);
># 4827 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_hd_deflate_change_table_size(nghttp2_hd_deflater *deflater,
> size_t settings_max_dynamic_table_size);
># 4858 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_hd_deflate_hd(nghttp2_hd_deflater *deflater,
> uint8_t *buf, size_t buflen,
> const nghttp2_nv *nva,
> size_t nvlen);
># 4890 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_hd_deflate_hd_vec(nghttp2_hd_deflater *deflater,
> const nghttp2_vec *vec,
> size_t veclen,
> const nghttp2_nv *nva,
> size_t nvlen);
>
>
>
>
>
>
>
> size_t nghttp2_hd_deflate_bound(nghttp2_hd_deflater *deflater,
> const nghttp2_nv *nva,
> size_t nvlen);
># 4913 "/usr/local/include/nghttp2/nghttp2.h" 3
>
>size_t nghttp2_hd_deflate_get_num_table_entries(nghttp2_hd_deflater *deflater);
># 4926 "/usr/local/include/nghttp2/nghttp2.h" 3
>
>const nghttp2_nv *
>nghttp2_hd_deflate_get_table_entry(nghttp2_hd_deflater *deflater, size_t idx);
>
>
>
>
>
>
>
>
>size_t nghttp2_hd_deflate_get_dynamic_table_size(nghttp2_hd_deflater *deflater);
>
>
>
>
>
>
>
>size_t
>nghttp2_hd_deflate_get_max_dynamic_table_size(nghttp2_hd_deflater *deflater);
>
>struct nghttp2_hd_inflater;
>
>
>
>
>
>
>typedef struct nghttp2_hd_inflater nghttp2_hd_inflater;
># 4970 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_hd_inflate_new(nghttp2_hd_inflater **inflater_ptr);
># 4987 "/usr/local/include/nghttp2/nghttp2.h" 3
> int nghttp2_hd_inflate_new2(nghttp2_hd_inflater **inflater_ptr,
> nghttp2_mem *mem);
>
>
>
>
>
>
> void nghttp2_hd_inflate_del(nghttp2_hd_inflater *inflater);
># 5023 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_hd_inflate_change_table_size(nghttp2_hd_inflater *inflater,
> size_t settings_max_dynamic_table_size);
>
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_HD_INFLATE_NONE = 0,
>
>
>
> NGHTTP2_HD_INFLATE_FINAL = 0x01,
>
>
>
> NGHTTP2_HD_INFLATE_EMIT = 0x02
>} nghttp2_hd_inflate_flag;
># 5128 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_hd_inflate_hd(nghttp2_hd_inflater *inflater,
> nghttp2_nv *nv_out,
> int *inflate_flags, uint8_t *in,
> size_t inlen, int in_final);
># 5214 "/usr/local/include/nghttp2/nghttp2.h" 3
> ssize_t nghttp2_hd_inflate_hd2(nghttp2_hd_inflater *inflater,
> nghttp2_nv *nv_out,
> int *inflate_flags,
> const uint8_t *in, size_t inlen,
> int in_final);
># 5228 "/usr/local/include/nghttp2/nghttp2.h" 3
> int
>nghttp2_hd_inflate_end_headers(nghttp2_hd_inflater *inflater);
># 5238 "/usr/local/include/nghttp2/nghttp2.h" 3
>
>size_t nghttp2_hd_inflate_get_num_table_entries(nghttp2_hd_inflater *inflater);
># 5251 "/usr/local/include/nghttp2/nghttp2.h" 3
>
>const nghttp2_nv *
>nghttp2_hd_inflate_get_table_entry(nghttp2_hd_inflater *inflater, size_t idx);
>
>
>
>
>
>
>
>
>size_t nghttp2_hd_inflate_get_dynamic_table_size(nghttp2_hd_inflater *inflater);
>
>
>
>
>
>
>
>size_t
>nghttp2_hd_inflate_get_max_dynamic_table_size(nghttp2_hd_inflater *inflater);
>
>struct nghttp2_stream;
>
>
>
>
>
>
>
>typedef struct nghttp2_stream nghttp2_stream;
># 5296 "/usr/local/include/nghttp2/nghttp2.h" 3
> nghttp2_stream *
>nghttp2_session_find_stream(nghttp2_session *session, int32_t stream_id);
>
>
>
>
>
>
>typedef enum {
>
>
>
> NGHTTP2_STREAM_STATE_IDLE = 1,
>
>
>
> NGHTTP2_STREAM_STATE_OPEN,
>
>
>
> NGHTTP2_STREAM_STATE_RESERVED_LOCAL,
>
>
>
> NGHTTP2_STREAM_STATE_RESERVED_REMOTE,
>
>
>
> NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL,
>
>
>
> NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE,
>
>
>
> NGHTTP2_STREAM_STATE_CLOSED
>} nghttp2_stream_proto_state;
># 5342 "/usr/local/include/nghttp2/nghttp2.h" 3
> nghttp2_stream_proto_state
>nghttp2_stream_get_state(nghttp2_stream *stream);
># 5352 "/usr/local/include/nghttp2/nghttp2.h" 3
> nghttp2_stream *
>nghttp2_session_get_root_stream(nghttp2_session *session);
>
>
>
>
>
>
>
> nghttp2_stream *
>nghttp2_stream_get_parent(nghttp2_stream *stream);
>
> int32_t nghttp2_stream_get_stream_id(nghttp2_stream *stream);
>
>
>
>
>
>
>
> nghttp2_stream *
>nghttp2_stream_get_next_sibling(nghttp2_stream *stream);
>
>
>
>
>
>
>
> nghttp2_stream *
>nghttp2_stream_get_previous_sibling(nghttp2_stream *stream);
>
>
>
>
>
>
>
> nghttp2_stream *
>nghttp2_stream_get_first_child(nghttp2_stream *stream);
>
>
>
>
>
>
> int32_t nghttp2_stream_get_weight(nghttp2_stream *stream);
>
>
>
>
>
>
> int32_t
>nghttp2_stream_get_sum_dependency_weight(nghttp2_stream *stream);
># 5417 "/usr/local/include/nghttp2/nghttp2.h" 3
>typedef void (*nghttp2_debug_vprintf_callback)(const char *format,
> va_list args);
># 5441 "/usr/local/include/nghttp2/nghttp2.h" 3
> void nghttp2_set_debug_vprintf_callback(
> nghttp2_debug_vprintf_callback debug_vprintf_callback);
>
>
>}
># 40 "/usr/local/include/nghttp2/asio_http2.h" 2 3
>
>namespace nghttp2 {
>
>namespace asio_http2 {
>
>struct header_value {
>
> std::string value;
>
>
>
>
> bool sensitive;
>};
>
>
>using header_map = std::multimap<std::string, header_value>;
>
>const boost::system::error_category &nghttp2_category() noexcept;
>
>struct uri_ref {
> std::string scheme;
> std::string host;
>
> std::string path;
>
> std::string raw_path;
>
> std::string raw_query;
> std::string fragment;
>};
>
>
>
>typedef std::function<void(const uint8_t *, std::size_t)> data_cb;
>typedef std::function<void(void)> void_cb;
>typedef std::function<void(const boost::system::error_code &ec)> error_cb;
>
>
>typedef std::function<void(uint32_t)> close_cb;
># 92 "/usr/local/include/nghttp2/asio_http2.h" 3
>typedef std::function<ssize_t(uint8_t *buf, std::size_t len,
> uint32_t *data_flags)>
> generator_cb;
>
>
>
>generator_cb file_generator(const std::string &path);
>
>
>
>
>generator_cb file_generator_from_fd(int fd);
>
>
>
>
>
>bool check_path(const std::string &path);
>
>
>std::string percent_decode(const std::string &s);
>
>
>std::string http_date(int64_t t);
>
>
>
>
>boost::system::error_code host_service_from_uri(boost::system::error_code &ec,
> std::string &scheme,
> std::string &host,
> std::string &service,
> const std::string &uri);
>
>enum nghttp2_asio_error {
> NGHTTP2_ASIO_ERR_NO_ERROR = 0,
> NGHTTP2_ASIO_ERR_TLS_NO_APP_PROTO_NEGOTIATED = 1,
>};
>
>}
>
>}
>
>namespace boost {
>
>namespace system {
>
>template <> struct is_error_code_enum<nghttp2_error> {
> static const bool value = true;
>};
>
>template <> struct is_error_code_enum<nghttp2::asio_http2::nghttp2_asio_error> {
> static const bool value = true;
>};
>
>}
>
>}
># 29 "/usr/local/include/nghttp2/asio_http2_client.h" 2 3
>
>namespace nghttp2 {
>
>namespace asio_http2 {
>
>namespace client {
>
>class response_impl;
>
>class response {
>public:
>
> response();
> ~response();
>
>
>
> void on_data(data_cb cb) const;
>
>
> int status_code() const;
>
>
> int64_t content_length() const;
>
>
>
> const header_map &header() const;
>
>
> response_impl &impl() const;
>
>private:
> std::unique_ptr<response_impl> impl_;
>};
>
>class request;
>
>using response_cb = std::function<void(const response &)>;
>using request_cb = std::function<void(const request &)>;
>using connect_cb =
> std::function<void(boost::asio::ip::tcp::resolver::iterator)>;
>
>class request_impl;
>
>class request {
>public:
>
> request();
> ~request();
>
>
> void on_response(response_cb cb) const;
>
>
>
> void on_push(request_cb cb) const;
>
>
>
>
> void on_close(close_cb cb) const;
>
>
>
>
>
> void write_trailer(header_map h) const;
>
>
> void cancel(uint32_t error_code = NGHTTP2_INTERNAL_ERROR) const;
>
>
> void resume() const;
>
>
> const std::string &method() const;
>
>
> const uri_ref &uri() const;
>
>
>
> const header_map &header() const;
>
>
> request_impl &impl() const;
>
>private:
> std::unique_ptr<request_impl> impl_;
>};
>
>
>class priority_spec {
>public:
>
> priority_spec() = default;
>
>
> explicit priority_spec(const int32_t stream_id, const int32_t weight,
> const bool exclusive = false);
>
>
> const nghttp2_priority_spec *get() const;
>
>
>
> const bool valid() const;
>
>private:
> nghttp2_priority_spec spec_;
> bool valid_ = false;
>};
>
>class session_impl;
>
>class session {
>public:
>
>
>
> session(boost::asio::io_service &io_service, const std::string &host,
> const std::string &service);
>
>
>
>
> session(boost::asio::io_service &io_service, const std::string &host,
> const std::string &service,
> const boost::posix_time::time_duration &connect_timeout);
>
>
>
>
> session(boost::asio::io_service &io_service,
> boost::asio::ssl::context &tls_context, const std::string &host,
> const std::string &service);
>
>
>
>
> session(boost::asio::io_service &io_service,
> boost::asio::ssl::context &tls_context, const std::string &host,
> const std::string &service,
> const boost::posix_time::time_duration &connect_timeout);
>
> ~session();
>
> session(session &&other) noexcept;
> session &operator=(session &&other) noexcept;
>
>
> void on_connect(connect_cb cb) const;
>
>
>
> void on_error(error_cb cb) const;
>
>
> void read_timeout(const boost::posix_time::time_duration &t);
>
>
> void shutdown() const;
>
>
> boost::asio::io_service &io_service() const;
>
>
>
>
>
> const request *submit(boost::system::error_code &ec,
> const std::string &method, const std::string &uri,
> header_map h = header_map{},
> priority_spec prio = priority_spec()) const;
>
>
>
>
>
>
> const request *submit(boost::system::error_code &ec,
> const std::string &method, const std::string &uri,
> std::string data, header_map h = header_map{},
> priority_spec prio = priority_spec()) const;
>
>
>
>
>
>
> const request *submit(boost::system::error_code &ec,
> const std::string &method, const std::string &uri,
> generator_cb cb, header_map h = header_map{},
> priority_spec prio = priority_spec()) const;
>
>private:
> std::shared_ptr<session_impl> impl_;
>};
>
>
>
>boost::system::error_code
>configure_tls_context(boost::system::error_code &ec,
> boost::asio::ssl::context &tls_ctx);
>
>}
>
>}
>
>}
># 6 "h2-client.cpp" 2
>
>
># 7 "h2-client.cpp"
>using boost::asio::ip::tcp;
>
>using namespace nghttp2::asio_http2;
>using namespace nghttp2::asio_http2::client;
>
>int main(int argc, char* argv[])
>{
> boost::system::error_code ec;
> boost::asio::io_service io_service;
>
> boost::asio::ssl::context tls(boost::asio::ssl::context::sslv23);
> tls.set_default_verify_paths();
>
> tls.set_verify_mode(boost::asio::ssl::verify_peer);
>
> configure_tls_context(ec, tls);
>
> auto constexpr server = "digilicious.com";
> auto constexpr port = "443";
>
> session sess(io_service, tls, server, port);
>
> sess.on_connect([&sess](tcp::resolver::iterator endpoint_it) {
> boost::system::error_code ec;
>
> auto const url = fmt::format("https://{}:{}/.well-known/mta-sts.txt", server, port);
>
> auto req = sess.submit(ec, "GET", url);
>
> req->on_response([&sess](const response& res) {
> std::cerr << "response received!" << std::endl;
> res.on_data([&sess](const uint8_t* data, std::size_t len) {
> std::cerr.write(reinterpret_cast<const char*>(data), len);
> std::cerr << std::endl;
> });
> });
>
> req->on_push([](const request& push) {
> std::cerr << "push request received!" << std::endl;
> push.on_response([](const response& res) {
> std::cerr << "push response received!" << std::endl;
> res.on_data([](const uint8_t* data, std::size_t len) {
> std::cerr.write(reinterpret_cast<const char*>(data), len);
> std::cerr << std::endl;
> });
> });
> });
> });
>
> sess.on_error([](const boost::system::error_code& ec) {
> std::cerr << "error: " << ec.message() << std::endl;
> });
>
> io_service.run();
>}

Actions: View

Attachments on bug 1595470: 1454838 | 1454839