# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
#define __llvm__ 1
#define __clang__ 1
#define __clang_major__ 5
#define __clang_minor__ 0
#define __clang_patchlevel__ 1
#define __clang_version__ "5.0.1 (git://github.com/llvm-mirror/clang.git 7e8743f82ac7957c66d9c2444996be5b1218673b) (git://github.com/llvm-mirror/llvm.git 81029f142231bde8e119becda112a2173f1459c9)"
#define __GNUC_MINOR__ 2
#define __GNUC_PATCHLEVEL__ 1
#define __GNUC__ 4
#define __GXX_ABI_VERSION 1002
#define __ATOMIC_RELAXED 0
#define __ATOMIC_CONSUME 1
#define __ATOMIC_ACQUIRE 2
#define __ATOMIC_RELEASE 3
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_SEQ_CST 5
#define __PRAGMA_REDEFINE_EXTNAME 1
#define __VERSION__ "4.2.1 Compatible Clang 5.0.1 (git://github.com/llvm-mirror/clang.git 7e8743f82ac7957c66d9c2444996be5b1218673b) (git://github.com/llvm-mirror/llvm.git 81029f142231bde8e119becda112a2173f1459c9)"
#define __GXX_EXPERIMENTAL_CXX0X__ 1
#define __OBJC_BOOL_IS_BOOL 0
#define __cpp_rtti 199711
#define __cpp_exceptions 199711
#define __cpp_unicode_characters 200704
#define __cpp_raw_strings 200710
#define __cpp_unicode_literals 200710
#define __cpp_user_defined_literals 200809
#define __cpp_lambdas 200907
#define __cpp_constexpr 200704
#define __cpp_range_based_for 200907
#define __cpp_static_assert 200410
#define __cpp_decltype 200707
#define __cpp_attributes 200809
#define __cpp_rvalue_references 200610
#define __cpp_variadic_templates 200704
#define __cpp_initializer_lists 200806
#define __cpp_delegating_constructors 200604
#define __cpp_nsdmi 200809
#define __cpp_inheriting_constructors 201511
#define __cpp_ref_qualifiers 200710
#define __cpp_alias_templates 200704
#define __cpp_threadsafe_static_init 200806
#define __CONSTANT_CFSTRINGS__ 1
#define __EXCEPTIONS 1
#define __GXX_RTTI 1
#define __DEPRECATED 1
#define __GNUG__ 4
#define __GXX_WEAK__ 1
#define __private_extern__ extern
#define __OPTIMIZE__ 1
#define __ORDER_LITTLE_ENDIAN__ 1234
#define __ORDER_BIG_ENDIAN__ 4321
#define __ORDER_PDP_ENDIAN__ 3412
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __LITTLE_ENDIAN__ 1
#define _LP64 1
#define __LP64__ 1
#define __CHAR_BIT__ 8
#define __SCHAR_MAX__ 127
#define __SHRT_MAX__ 32767
#define __INT_MAX__ 2147483647
#define __LONG_MAX__ 9223372036854775807L
#define __LONG_LONG_MAX__ 9223372036854775807LL
#define __WCHAR_MAX__ 4294967295U
#define __INTMAX_MAX__ 9223372036854775807L
#define __SIZE_MAX__ 18446744073709551615UL
#define __UINTMAX_MAX__ 18446744073709551615UL
#define __PTRDIFF_MAX__ 9223372036854775807L
#define __INTPTR_MAX__ 9223372036854775807L
#define __UINTPTR_MAX__ 18446744073709551615UL
#define __SIZEOF_DOUBLE__ 8
#define __SIZEOF_FLOAT__ 4
#define __SIZEOF_INT__ 4
#define __SIZEOF_LONG__ 8
#define __SIZEOF_LONG_DOUBLE__ 16
#define __SIZEOF_LONG_LONG__ 8
#define __SIZEOF_POINTER__ 8
#define __SIZEOF_SHORT__ 2
#define __SIZEOF_PTRDIFF_T__ 8
#define __SIZEOF_SIZE_T__ 8
#define __SIZEOF_WCHAR_T__ 4
#define __SIZEOF_WINT_T__ 4
#define __SIZEOF_INT128__ 16
#define __INTMAX_TYPE__ long int
#define __INTMAX_FMTd__ "ld"
#define __INTMAX_FMTi__ "li"
#define __INTMAX_C_SUFFIX__ L
#define __UINTMAX_TYPE__ long unsigned int
#define __UINTMAX_FMTo__ "lo"
#define __UINTMAX_FMTu__ "lu"
#define __UINTMAX_FMTx__ "lx"
#define __UINTMAX_FMTX__ "lX"
#define __UINTMAX_C_SUFFIX__ UL
#define __INTMAX_WIDTH__ 64
#define __PTRDIFF_TYPE__ long int
#define __PTRDIFF_FMTd__ "ld"
#define __PTRDIFF_FMTi__ "li"
#define __PTRDIFF_WIDTH__ 64
#define __INTPTR_TYPE__ long int
#define __INTPTR_FMTd__ "ld"
#define __INTPTR_FMTi__ "li"
#define __INTPTR_WIDTH__ 64
#define __SIZE_TYPE__ long unsigned int
#define __SIZE_FMTo__ "lo"
#define __SIZE_FMTu__ "lu"
#define __SIZE_FMTx__ "lx"
#define __SIZE_FMTX__ "lX"
#define __SIZE_WIDTH__ 64
#define __WCHAR_TYPE__ unsigned int
#define __WCHAR_WIDTH__ 32
#define __WINT_TYPE__ unsigned int
#define __WINT_WIDTH__ 32
#define __SIG_ATOMIC_WIDTH__ 32
#define __SIG_ATOMIC_MAX__ 2147483647
#define __CHAR16_TYPE__ unsigned short
#define __CHAR32_TYPE__ unsigned int
#define __UINTMAX_WIDTH__ 64
#define __UINTPTR_TYPE__ long unsigned int
#define __UINTPTR_FMTo__ "lo"
#define __UINTPTR_FMTu__ "lu"
#define __UINTPTR_FMTx__ "lx"
#define __UINTPTR_FMTX__ "lX"
#define __UINTPTR_WIDTH__ 64
#define __FLT_DENORM_MIN__ 1.40129846e-45F
#define __FLT_HAS_DENORM__ 1
#define __FLT_DIG__ 6
#define __FLT_DECIMAL_DIG__ 9
#define __FLT_EPSILON__ 1.19209290e-7F
#define __FLT_HAS_INFINITY__ 1
#define __FLT_HAS_QUIET_NAN__ 1
#define __FLT_MANT_DIG__ 24
#define __FLT_MAX_10_EXP__ 38
#define __FLT_MAX_EXP__ 128
#define __FLT_MAX__ 3.40282347e+38F
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT_MIN_EXP__ (-125)
#define __FLT_MIN__ 1.17549435e-38F
#define __DBL_DENORM_MIN__ 4.9406564584124654e-324
#define __DBL_HAS_DENORM__ 1
#define __DBL_DIG__ 15
#define __DBL_DECIMAL_DIG__ 17
#define __DBL_EPSILON__ 2.2204460492503131e-16
#define __DBL_HAS_INFINITY__ 1
#define __DBL_HAS_QUIET_NAN__ 1
#define __DBL_MANT_DIG__ 53
#define __DBL_MAX_10_EXP__ 308
#define __DBL_MAX_EXP__ 1024
#define __DBL_MAX__ 1.7976931348623157e+308
#define __DBL_MIN_10_EXP__ (-307)
#define __DBL_MIN_EXP__ (-1021)
#define __DBL_MIN__ 2.2250738585072014e-308
#define __LDBL_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966L
#define __LDBL_HAS_DENORM__ 1
#define __LDBL_DIG__ 33
#define __LDBL_DECIMAL_DIG__ 36
#define __LDBL_EPSILON__ 1.92592994438723585305597794258492732e-34L
#define __LDBL_HAS_INFINITY__ 1
#define __LDBL_HAS_QUIET_NAN__ 1
#define __LDBL_MANT_DIG__ 113
#define __LDBL_MAX_10_EXP__ 4932
#define __LDBL_MAX_EXP__ 16384
#define __LDBL_MAX__ 1.18973149535723176508575932662800702e+4932L
#define __LDBL_MIN_10_EXP__ (-4931)
#define __LDBL_MIN_EXP__ (-16381)
#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
#define __POINTER_WIDTH__ 64
#define __BIGGEST_ALIGNMENT__ 16
#define __CHAR_UNSIGNED__ 1
#define __WCHAR_UNSIGNED__ 1
#define __WINT_UNSIGNED__ 1
#define __INT8_TYPE__ signed char
#define __INT8_FMTd__ "hhd"
#define __INT8_FMTi__ "hhi"
#define __INT8_C_SUFFIX__ 
#define __INT16_TYPE__ short
#define __INT16_FMTd__ "hd"
#define __INT16_FMTi__ "hi"
#define __INT16_C_SUFFIX__ 
#define __INT32_TYPE__ int
#define __INT32_FMTd__ "d"
#define __INT32_FMTi__ "i"
#define __INT32_C_SUFFIX__ 
#define __INT64_TYPE__ long int
#define __INT64_FMTd__ "ld"
#define __INT64_FMTi__ "li"
#define __INT64_C_SUFFIX__ L
#define __UINT8_TYPE__ unsigned char
#define __UINT8_FMTo__ "hho"
#define __UINT8_FMTu__ "hhu"
#define __UINT8_FMTx__ "hhx"
#define __UINT8_FMTX__ "hhX"
#define __UINT8_C_SUFFIX__ 
#define __UINT8_MAX__ 255
#define __INT8_MAX__ 127
#define __UINT16_TYPE__ unsigned short
#define __UINT16_FMTo__ "ho"
#define __UINT16_FMTu__ "hu"
#define __UINT16_FMTx__ "hx"
#define __UINT16_FMTX__ "hX"
#define __UINT16_C_SUFFIX__ 
#define __UINT16_MAX__ 65535
#define __INT16_MAX__ 32767
#define __UINT32_TYPE__ unsigned int
#define __UINT32_FMTo__ "o"
#define __UINT32_FMTu__ "u"
#define __UINT32_FMTx__ "x"
#define __UINT32_FMTX__ "X"
#define __UINT32_C_SUFFIX__ U
#define __UINT32_MAX__ 4294967295U
#define __INT32_MAX__ 2147483647
#define __UINT64_TYPE__ long unsigned int
#define __UINT64_FMTo__ "lo"
#define __UINT64_FMTu__ "lu"
#define __UINT64_FMTx__ "lx"
#define __UINT64_FMTX__ "lX"
#define __UINT64_C_SUFFIX__ UL
#define __UINT64_MAX__ 18446744073709551615UL
#define __INT64_MAX__ 9223372036854775807L
#define __INT_LEAST8_TYPE__ signed char
#define __INT_LEAST8_MAX__ 127
#define __INT_LEAST8_FMTd__ "hhd"
#define __INT_LEAST8_FMTi__ "hhi"
#define __UINT_LEAST8_TYPE__ unsigned char
#define __UINT_LEAST8_MAX__ 255
#define __UINT_LEAST8_FMTo__ "hho"
#define __UINT_LEAST8_FMTu__ "hhu"
#define __UINT_LEAST8_FMTx__ "hhx"
#define __UINT_LEAST8_FMTX__ "hhX"
#define __INT_LEAST16_TYPE__ short
#define __INT_LEAST16_MAX__ 32767
#define __INT_LEAST16_FMTd__ "hd"
#define __INT_LEAST16_FMTi__ "hi"
#define __UINT_LEAST16_TYPE__ unsigned short
#define __UINT_LEAST16_MAX__ 65535
#define __UINT_LEAST16_FMTo__ "ho"
#define __UINT_LEAST16_FMTu__ "hu"
#define __UINT_LEAST16_FMTx__ "hx"
#define __UINT_LEAST16_FMTX__ "hX"
#define __INT_LEAST32_TYPE__ int
#define __INT_LEAST32_MAX__ 2147483647
#define __INT_LEAST32_FMTd__ "d"
#define __INT_LEAST32_FMTi__ "i"
#define __UINT_LEAST32_TYPE__ unsigned int
#define __UINT_LEAST32_MAX__ 4294967295U
#define __UINT_LEAST32_FMTo__ "o"
#define __UINT_LEAST32_FMTu__ "u"
#define __UINT_LEAST32_FMTx__ "x"
#define __UINT_LEAST32_FMTX__ "X"
#define __INT_LEAST64_TYPE__ long int
#define __INT_LEAST64_MAX__ 9223372036854775807L
#define __INT_LEAST64_FMTd__ "ld"
#define __INT_LEAST64_FMTi__ "li"
#define __UINT_LEAST64_TYPE__ long unsigned int
#define __UINT_LEAST64_MAX__ 18446744073709551615UL
#define __UINT_LEAST64_FMTo__ "lo"
#define __UINT_LEAST64_FMTu__ "lu"
#define __UINT_LEAST64_FMTx__ "lx"
#define __UINT_LEAST64_FMTX__ "lX"
#define __INT_FAST8_TYPE__ signed char
#define __INT_FAST8_MAX__ 127
#define __INT_FAST8_FMTd__ "hhd"
#define __INT_FAST8_FMTi__ "hhi"
#define __UINT_FAST8_TYPE__ unsigned char
#define __UINT_FAST8_MAX__ 255
#define __UINT_FAST8_FMTo__ "hho"
#define __UINT_FAST8_FMTu__ "hhu"
#define __UINT_FAST8_FMTx__ "hhx"
#define __UINT_FAST8_FMTX__ "hhX"
#define __INT_FAST16_TYPE__ short
#define __INT_FAST16_MAX__ 32767
#define __INT_FAST16_FMTd__ "hd"
#define __INT_FAST16_FMTi__ "hi"
#define __UINT_FAST16_TYPE__ unsigned short
#define __UINT_FAST16_MAX__ 65535
#define __UINT_FAST16_FMTo__ "ho"
#define __UINT_FAST16_FMTu__ "hu"
#define __UINT_FAST16_FMTx__ "hx"
#define __UINT_FAST16_FMTX__ "hX"
#define __INT_FAST32_TYPE__ int
#define __INT_FAST32_MAX__ 2147483647
#define __INT_FAST32_FMTd__ "d"
#define __INT_FAST32_FMTi__ "i"
#define __UINT_FAST32_TYPE__ unsigned int
#define __UINT_FAST32_MAX__ 4294967295U
#define __UINT_FAST32_FMTo__ "o"
#define __UINT_FAST32_FMTu__ "u"
#define __UINT_FAST32_FMTx__ "x"
#define __UINT_FAST32_FMTX__ "X"
#define __INT_FAST64_TYPE__ long int
#define __INT_FAST64_MAX__ 9223372036854775807L
#define __INT_FAST64_FMTd__ "ld"
#define __INT_FAST64_FMTi__ "li"
#define __UINT_FAST64_TYPE__ long unsigned int
#define __UINT_FAST64_MAX__ 18446744073709551615UL
#define __UINT_FAST64_FMTo__ "lo"
#define __UINT_FAST64_FMTu__ "lu"
#define __UINT_FAST64_FMTx__ "lx"
#define __UINT_FAST64_FMTX__ "lX"
#define __USER_LABEL_PREFIX__ 
#define __FINITE_MATH_ONLY__ 0
#define __GNUC_GNU_INLINE__ 1
#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
#define __CLANG_ATOMIC_BOOL_LOCK_FREE 2
#define __CLANG_ATOMIC_CHAR_LOCK_FREE 2
#define __CLANG_ATOMIC_CHAR16_T_LOCK_FREE 2
#define __CLANG_ATOMIC_CHAR32_T_LOCK_FREE 2
#define __CLANG_ATOMIC_WCHAR_T_LOCK_FREE 2
#define __CLANG_ATOMIC_SHORT_LOCK_FREE 2
#define __CLANG_ATOMIC_INT_LOCK_FREE 2
#define __CLANG_ATOMIC_LONG_LOCK_FREE 2
#define __CLANG_ATOMIC_LLONG_LOCK_FREE 2
#define __CLANG_ATOMIC_POINTER_LOCK_FREE 2
#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
#define __GCC_ATOMIC_INT_LOCK_FREE 2
#define __GCC_ATOMIC_LONG_LOCK_FREE 2
#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
#define __PIC__ 2
#define __pic__ 2
#define __PIE__ 2
#define __pie__ 2
#define __FLT_EVAL_METHOD__ 0
#define __FLT_RADIX__ 2
#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
#define __SSP_STRONG__ 2
#define __GLIBCXX_TYPE_INT_N_0 __int128
#define __GLIBCXX_BITSIZE_INT_N_0 128
#define __AARCH64EL__ 1
#define __aarch64__ 1
#define _LP64 1
#define __LP64__ 1
#define __ARM_ACLE 200
#define __ARM_ARCH 8
#define __ARM_ARCH_PROFILE 'A'
#define __ARM_64BIT_STATE 1
#define __ARM_PCS_AAPCS64 1
#define __ARM_ARCH_ISA_A64 1
#define __ARM_FEATURE_CLZ 1
#define __ARM_FEATURE_FMA 1
#define __ARM_FEATURE_LDREX 0xF
#define __ARM_FEATURE_IDIV 1
#define __ARM_FEATURE_DIV 1
#define __ARM_FEATURE_NUMERIC_MAXMIN 1
#define __ARM_FEATURE_DIRECTED_ROUNDING 1
#define __ARM_ALIGN_MAX_STACK_PWR 4
#define __ARM_FP 0xE
#define __ARM_FP16_FORMAT_IEEE 1
#define __ARM_FP16_ARGS 1
#define __ARM_SIZEOF_WCHAR_T 4
#define __ARM_SIZEOF_MINIMAL_ENUM 4
#define __ARM_NEON 1
#define __ARM_NEON_FP 0xE
#define __ARM_FEATURE_UNALIGNED 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
#define unix 1
#define __unix 1
#define __unix__ 1
#define linux 1
#define __linux 1
#define __linux__ 1
#define __gnu_linux__ 1
#define __ELF__ 1
#define _REENTRANT 1
#define _GNU_SOURCE 1
#define __STDC__ 1
#define __STDC_HOSTED__ 1
#define __cplusplus 201103L
#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16UL
#define __STDC_UTF_16__ 1
#define __STDC_UTF_32__ 1

# 1 "<command line>" 1
#define __extern_always_inline inline
#define _FORTIFY_SOURCE 2
#define __extern_always_inline inline
# 1 "<built-in>" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 25 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++"
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.capnp.h" 1




#define CAPNP_INCLUDED_a93fc509624c72d9_ 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 1
# 25 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h"
#define CAPNP_GENERATED_HEADER_SUPPORT_H_ 
# 29 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/raw-schema.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/raw-schema.h" 3
#define CAPNP_RAW_SCHEMA_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/raw-schema.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 1 3
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
#define CAPNP_COMMON_H_ 
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/inttypes.h" 1 3
# 24 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/inttypes.h" 3
#define __CLANG_INTTYPES_H 






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/inttypes.h" 1 3 4

#define _INTTYPES_H 


extern "C" {



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/features.h" 1 3 4

#define _FEATURES_H 
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/features.h" 3 4
#define __inline inline






#define _Noreturn __attribute__((__noreturn__))
# 9 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/inttypes.h" 2 3 4
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stdint.h" 1 3 4
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stdint.h" 3 4
#define __CLANG_STDINT_H 
# 54 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stdint.h" 3 4
#define __STDC_LIMIT_MACROS 
#define __STDC_LIMIT_MACROS_DEFINED_BY_CLANG 


#define __STDC_CONSTANT_MACROS 
#define __STDC_CONSTANT_MACROS_DEFINED_BY_CLANG 




# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdint.h" 1 3 4

#define _STDINT_H 

#define __NEED_int8_t 
#define __NEED_int16_t 
#define __NEED_int32_t 
#define __NEED_int64_t 

#define __NEED_uint8_t 
#define __NEED_uint16_t 
#define __NEED_uint32_t 
#define __NEED_uint64_t 

#define __NEED_intptr_t 
#define __NEED_uintptr_t 

#define __NEED_intmax_t 
#define __NEED_uintmax_t 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 109 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long uintptr_t;
#define __DEFINED_uintptr_t 
# 124 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef long intptr_t;
#define __DEFINED_intptr_t 
# 140 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef signed char int8_t;
#define __DEFINED_int8_t 



typedef short int16_t;
#define __DEFINED_int16_t 



typedef int int32_t;
#define __DEFINED_int32_t 



typedef long int64_t;
#define __DEFINED_int64_t 



typedef long intmax_t;
#define __DEFINED_intmax_t 



typedef unsigned char uint8_t;
#define __DEFINED_uint8_t 



typedef unsigned short uint16_t;
#define __DEFINED_uint16_t 



typedef unsigned int uint32_t;
#define __DEFINED_uint32_t 



typedef unsigned long uint64_t;
#define __DEFINED_uint64_t 








typedef unsigned long uintmax_t;
#define __DEFINED_uintmax_t 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 21 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdint.h" 2 3 4

typedef int8_t int_fast8_t;
typedef int64_t int_fast64_t;

typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;

typedef uint8_t uint_fast8_t;
typedef uint64_t uint_fast64_t;

typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;

#define INT8_MIN (-1-0x7f)
#define INT16_MIN (-1-0x7fff)
#define INT32_MIN (-1-0x7fffffff)
#define INT64_MIN (-1-0x7fffffffffffffff)

#define INT8_MAX (0x7f)
#define INT16_MAX (0x7fff)
#define INT32_MAX (0x7fffffff)
#define INT64_MAX (0x7fffffffffffffff)

#define UINT8_MAX (0xff)
#define UINT16_MAX (0xffff)
#define UINT32_MAX (0xffffffffu)
#define UINT64_MAX (0xffffffffffffffffu)

#define INT_FAST8_MIN INT8_MIN
#define INT_FAST64_MIN INT64_MIN

#define INT_LEAST8_MIN INT8_MIN
#define INT_LEAST16_MIN INT16_MIN
#define INT_LEAST32_MIN INT32_MIN
#define INT_LEAST64_MIN INT64_MIN

#define INT_FAST8_MAX INT8_MAX
#define INT_FAST64_MAX INT64_MAX

#define INT_LEAST8_MAX INT8_MAX
#define INT_LEAST16_MAX INT16_MAX
#define INT_LEAST32_MAX INT32_MAX
#define INT_LEAST64_MAX INT64_MAX

#define UINT_FAST8_MAX UINT8_MAX
#define UINT_FAST64_MAX UINT64_MAX

#define UINT_LEAST8_MAX UINT8_MAX
#define UINT_LEAST16_MAX UINT16_MAX
#define UINT_LEAST32_MAX UINT32_MAX
#define UINT_LEAST64_MAX UINT64_MAX

#define INTMAX_MIN INT64_MIN
#define INTMAX_MAX INT64_MAX
#define UINTMAX_MAX UINT64_MAX

#define WINT_MIN 0U
#define WINT_MAX UINT32_MAX


#define WCHAR_MAX (0xffffffffu+L'\0')
#define WCHAR_MIN (0+L'\0')





#define SIG_ATOMIC_MIN INT32_MIN
#define SIG_ATOMIC_MAX INT32_MAX


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/stdint.h" 1 3 4
typedef int32_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef uint32_t uint_fast16_t;
typedef uint32_t uint_fast32_t;

#define INT_FAST16_MIN INT32_MIN
#define INT_FAST32_MIN INT32_MIN

#define INT_FAST16_MAX INT32_MAX
#define INT_FAST32_MAX INT32_MAX

#define UINT_FAST16_MAX UINT32_MAX
#define UINT_FAST32_MAX UINT32_MAX

#define INTPTR_MIN INT64_MIN
#define INTPTR_MAX INT64_MAX
#define UINTPTR_MAX UINT64_MAX
#define PTRDIFF_MIN INT64_MIN
#define PTRDIFF_MAX INT64_MAX
#define SIZE_MAX UINT64_MAX
# 96 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdint.h" 2 3 4

#define INT8_C(c) c
#define INT16_C(c) c
#define INT32_C(c) c

#define UINT8_C(c) c
#define UINT16_C(c) c
#define UINT32_C(c) c ## U


#define INT64_C(c) c ## L
#define UINT64_C(c) c ## UL
#define INTMAX_C(c) c ## L
#define UINTMAX_C(c) c ## UL
# 64 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stdint.h" 2 3 4


#undef __STDC_LIMIT_MACROS
#undef __STDC_LIMIT_MACROS_DEFINED_BY_CLANG


#undef __STDC_CONSTANT_MACROS
#undef __STDC_CONSTANT_MACROS_DEFINED_BY_CLANG
# 10 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/inttypes.h" 2 3 4

#define __NEED_wchar_t 

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 13 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/inttypes.h" 2 3 4

typedef struct { intmax_t quot, rem; } imaxdiv_t;

intmax_t imaxabs(intmax_t);
imaxdiv_t imaxdiv(intmax_t, intmax_t);

intmax_t strtoimax(const char *__restrict, char **__restrict, int);
uintmax_t strtoumax(const char *__restrict, char **__restrict, int);

intmax_t wcstoimax(const wchar_t *__restrict, wchar_t **__restrict, int);
uintmax_t wcstoumax(const wchar_t *__restrict, wchar_t **__restrict, int);


#define __PRI64 "l"
#define __PRIPTR "l"





#define PRId8 "d"
#define PRId16 "d"
#define PRId32 "d"
#define PRId64 __PRI64 "d"

#define PRIdLEAST8 "d"
#define PRIdLEAST16 "d"
#define PRIdLEAST32 "d"
#define PRIdLEAST64 __PRI64 "d"

#define PRIdFAST8 "d"
#define PRIdFAST16 "d"
#define PRIdFAST32 "d"
#define PRIdFAST64 __PRI64 "d"

#define PRIi8 "i"
#define PRIi16 "i"
#define PRIi32 "i"
#define PRIi64 __PRI64 "i"

#define PRIiLEAST8 "i"
#define PRIiLEAST16 "i"
#define PRIiLEAST32 "i"
#define PRIiLEAST64 __PRI64 "i"

#define PRIiFAST8 "i"
#define PRIiFAST16 "i"
#define PRIiFAST32 "i"
#define PRIiFAST64 __PRI64 "i"

#define PRIo8 "o"
#define PRIo16 "o"
#define PRIo32 "o"
#define PRIo64 __PRI64 "o"

#define PRIoLEAST8 "o"
#define PRIoLEAST16 "o"
#define PRIoLEAST32 "o"
#define PRIoLEAST64 __PRI64 "o"

#define PRIoFAST8 "o"
#define PRIoFAST16 "o"
#define PRIoFAST32 "o"
#define PRIoFAST64 __PRI64 "o"

#define PRIu8 "u"
#define PRIu16 "u"
#define PRIu32 "u"
#define PRIu64 __PRI64 "u"

#define PRIuLEAST8 "u"
#define PRIuLEAST16 "u"
#define PRIuLEAST32 "u"
#define PRIuLEAST64 __PRI64 "u"

#define PRIuFAST8 "u"
#define PRIuFAST16 "u"
#define PRIuFAST32 "u"
#define PRIuFAST64 __PRI64 "u"

#define PRIx8 "x"
#define PRIx16 "x"
#define PRIx32 "x"
#define PRIx64 __PRI64 "x"

#define PRIxLEAST8 "x"
#define PRIxLEAST16 "x"
#define PRIxLEAST32 "x"
#define PRIxLEAST64 __PRI64 "x"

#define PRIxFAST8 "x"
#define PRIxFAST16 "x"
#define PRIxFAST32 "x"
#define PRIxFAST64 __PRI64 "x"

#define PRIX8 "X"
#define PRIX16 "X"
#define PRIX32 "X"
#define PRIX64 __PRI64 "X"

#define PRIXLEAST8 "X"
#define PRIXLEAST16 "X"
#define PRIXLEAST32 "X"
#define PRIXLEAST64 __PRI64 "X"

#define PRIXFAST8 "X"
#define PRIXFAST16 "X"
#define PRIXFAST32 "X"
#define PRIXFAST64 __PRI64 "X"

#define PRIdMAX __PRI64 "d"
#define PRIiMAX __PRI64 "i"
#define PRIoMAX __PRI64 "o"
#define PRIuMAX __PRI64 "u"
#define PRIxMAX __PRI64 "x"
#define PRIXMAX __PRI64 "X"

#define PRIdPTR __PRIPTR "d"
#define PRIiPTR __PRIPTR "i"
#define PRIoPTR __PRIPTR "o"
#define PRIuPTR __PRIPTR "u"
#define PRIxPTR __PRIPTR "x"
#define PRIXPTR __PRIPTR "X"

#define SCNd8 "hhd"
#define SCNd16 "hd"
#define SCNd32 "d"
#define SCNd64 __PRI64 "d"

#define SCNdLEAST8 "hhd"
#define SCNdLEAST16 "hd"
#define SCNdLEAST32 "d"
#define SCNdLEAST64 __PRI64 "d"

#define SCNdFAST8 "hhd"
#define SCNdFAST16 "d"
#define SCNdFAST32 "d"
#define SCNdFAST64 __PRI64 "d"

#define SCNi8 "hhi"
#define SCNi16 "hi"
#define SCNi32 "i"
#define SCNi64 __PRI64 "i"

#define SCNiLEAST8 "hhi"
#define SCNiLEAST16 "hi"
#define SCNiLEAST32 "i"
#define SCNiLEAST64 __PRI64 "i"

#define SCNiFAST8 "hhi"
#define SCNiFAST16 "i"
#define SCNiFAST32 "i"
#define SCNiFAST64 __PRI64 "i"

#define SCNu8 "hhu"
#define SCNu16 "hu"
#define SCNu32 "u"
#define SCNu64 __PRI64 "u"

#define SCNuLEAST8 "hhu"
#define SCNuLEAST16 "hu"
#define SCNuLEAST32 "u"
#define SCNuLEAST64 __PRI64 "u"

#define SCNuFAST8 "hhu"
#define SCNuFAST16 "u"
#define SCNuFAST32 "u"
#define SCNuFAST64 __PRI64 "u"

#define SCNo8 "hho"
#define SCNo16 "ho"
#define SCNo32 "o"
#define SCNo64 __PRI64 "o"

#define SCNoLEAST8 "hho"
#define SCNoLEAST16 "ho"
#define SCNoLEAST32 "o"
#define SCNoLEAST64 __PRI64 "o"

#define SCNoFAST8 "hho"
#define SCNoFAST16 "o"
#define SCNoFAST32 "o"
#define SCNoFAST64 __PRI64 "o"

#define SCNx8 "hhx"
#define SCNx16 "hx"
#define SCNx32 "x"
#define SCNx64 __PRI64 "x"

#define SCNxLEAST8 "hhx"
#define SCNxLEAST16 "hx"
#define SCNxLEAST32 "x"
#define SCNxLEAST64 __PRI64 "x"

#define SCNxFAST8 "hhx"
#define SCNxFAST16 "x"
#define SCNxFAST32 "x"
#define SCNxFAST64 __PRI64 "x"

#define SCNdMAX __PRI64 "d"
#define SCNiMAX __PRI64 "i"
#define SCNoMAX __PRI64 "o"
#define SCNuMAX __PRI64 "u"
#define SCNxMAX __PRI64 "x"

#define SCNdPTR __PRIPTR "d"
#define SCNiPTR __PRIPTR "i"
#define SCNoPTR __PRIPTR "o"
#define SCNuPTR __PRIPTR "u"
#define SCNxPTR __PRIPTR "x"


}
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/inttypes.h" 2 3
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3
#define KJ_STRING_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/initializer_list" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/initializer_list" 3
#define _INITIALIZER_LIST 
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/initializer_list" 3





#pragma GCC visibility push(default)


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_CXX_CONFIG_H 1


#define _GLIBCXX_RELEASE 7


#define __GLIBCXX__ 20170814
# 46 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_PURE __attribute__ ((__pure__))



#define _GLIBCXX_CONST __attribute__ ((__const__))



#define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
# 67 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1


#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
# 81 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_USE_DEPRECATED 1



#define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))






#define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
# 101 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_CONSTEXPR constexpr
#define _GLIBCXX_USE_CONSTEXPR constexpr
# 113 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX14_CONSTEXPR 







#define _GLIBCXX17_CONSTEXPR 







#define _GLIBCXX17_INLINE 






#define _GLIBCXX_NOEXCEPT noexcept
#define _GLIBCXX_NOEXCEPT_IF(_COND) noexcept(_COND)
#define _GLIBCXX_USE_NOEXCEPT noexcept
#define _GLIBCXX_THROW(_EXC) 
# 149 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT




#define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
# 164 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_NOEXCEPT_PARM 
#define _GLIBCXX_NOEXCEPT_QUAL 
# 178 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_EXTERN_TEMPLATE 1
# 229 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
namespace std
{
  typedef long unsigned int size_t;
  typedef long int ptrdiff_t;


  typedef decltype(nullptr) nullptr_t;

}

#define _GLIBCXX_USE_DUAL_ABI 1







#define _GLIBCXX_USE_CXX11_ABI 1



namespace std
{
  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
#define _GLIBCXX_NAMESPACE_CXX11 __cxx11::
#define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 {
#define _GLIBCXX_END_NAMESPACE_CXX11 }
#define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11
# 272 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_INLINE_VERSION 0
# 330 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_BEGIN_NAMESPACE_VERSION 
#define _GLIBCXX_END_NAMESPACE_VERSION 
# 403 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_STD_C std
#define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _GLIBCXX_END_NAMESPACE_CONTAINER _GLIBCXX_END_NAMESPACE_VERSION
# 415 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_STD_A std
#define _GLIBCXX_BEGIN_NAMESPACE_ALGO _GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _GLIBCXX_END_NAMESPACE_ALGO _GLIBCXX_END_NAMESPACE_VERSION




#undef _GLIBCXX_LONG_DOUBLE_COMPAT
# 434 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_NAMESPACE_LDBL 
#define _GLIBCXX_BEGIN_NAMESPACE_LDBL 
#define _GLIBCXX_END_NAMESPACE_LDBL 


#define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11
#define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11
#define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11
# 487 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define __glibcxx_assert(_Condition) 
# 512 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) 


#define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) 



#define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
#define _GLIBCXX_END_EXTERN_C }

#define _GLIBCXX_USE_ALLOCATOR_NEW 1
# 533 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/os_defines.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/os_defines.h" 3
#define _GLIBCXX_OS_DEFINES 1







#define _GLIBCXX_GTHREAD_USE_WEAK 0
# 534 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 2 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/cpu_defines.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/cpu_defines.h" 3
#define _GLIBCXX_CPU_DEFINES 1
# 537 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 2 3




#define _GLIBCXX_PSEUDO_VISIBILITY(V) 






#define _GLIBCXX_WEAK_DEFINITION 







#define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__
# 569 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_TXN_SAFE 
#define _GLIBCXX_TXN_SAFE_DYN 
# 588 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_FAST_MATH 0






#define __N(msgid) (msgid)


#undef min
#undef max





#define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH


#define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX


#define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO


#define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB


#define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR
# 642 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_ACOSF 1


#define _GLIBCXX_HAVE_ACOSL 1


#define _GLIBCXX_HAVE_ALIGNED_ALLOC 1


#define _GLIBCXX_HAVE_ASINF 1


#define _GLIBCXX_HAVE_ASINL 1


#define _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE 1


#define _GLIBCXX_HAVE_ATAN2F 1


#define _GLIBCXX_HAVE_ATAN2L 1


#define _GLIBCXX_HAVE_ATANF 1


#define _GLIBCXX_HAVE_ATANL 1


#define _GLIBCXX_HAVE_AT_QUICK_EXIT 1





#define _GLIBCXX_HAVE_CEILF 1


#define _GLIBCXX_HAVE_CEILL 1


#define _GLIBCXX_HAVE_COMPLEX_H 1


#define _GLIBCXX_HAVE_COSF 1


#define _GLIBCXX_HAVE_COSHF 1


#define _GLIBCXX_HAVE_COSHL 1


#define _GLIBCXX_HAVE_COSL 1


#define _GLIBCXX_HAVE_DIRENT_H 1


#define _GLIBCXX_HAVE_DLFCN_H 1


#define _GLIBCXX_HAVE_EBADMSG 1


#define _GLIBCXX_HAVE_ECANCELED 1


#define _GLIBCXX_HAVE_ECHILD 1


#define _GLIBCXX_HAVE_EIDRM 1


#define _GLIBCXX_HAVE_ENDIAN_H 1


#define _GLIBCXX_HAVE_ENODATA 1


#define _GLIBCXX_HAVE_ENOLINK 1


#define _GLIBCXX_HAVE_ENOSPC 1


#define _GLIBCXX_HAVE_ENOSR 1


#define _GLIBCXX_HAVE_ENOSTR 1


#define _GLIBCXX_HAVE_ENOTRECOVERABLE 1


#define _GLIBCXX_HAVE_ENOTSUP 1


#define _GLIBCXX_HAVE_EOVERFLOW 1


#define _GLIBCXX_HAVE_EOWNERDEAD 1


#define _GLIBCXX_HAVE_EPERM 1


#define _GLIBCXX_HAVE_EPROTO 1


#define _GLIBCXX_HAVE_ETIME 1


#define _GLIBCXX_HAVE_ETIMEDOUT 1


#define _GLIBCXX_HAVE_ETXTBSY 1


#define _GLIBCXX_HAVE_EWOULDBLOCK 1


#define _GLIBCXX_HAVE_EXCEPTION_PTR_SINCE_GCC46 1





#define _GLIBCXX_HAVE_EXPF 1


#define _GLIBCXX_HAVE_EXPL 1


#define _GLIBCXX_HAVE_FABSF 1


#define _GLIBCXX_HAVE_FABSL 1


#define _GLIBCXX_HAVE_FCNTL_H 1


#define _GLIBCXX_HAVE_FENV_H 1


#define _GLIBCXX_HAVE_FINITE 1


#define _GLIBCXX_HAVE_FINITEF 1





#define _GLIBCXX_HAVE_FLOAT_H 1


#define _GLIBCXX_HAVE_FLOORF 1


#define _GLIBCXX_HAVE_FLOORL 1


#define _GLIBCXX_HAVE_FMODF 1


#define _GLIBCXX_HAVE_FMODL 1
# 819 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_FREXPF 1


#define _GLIBCXX_HAVE_FREXPL 1


#define _GLIBCXX_HAVE_GETIPINFO 1


#define _GLIBCXX_HAVE_GETS 1


#define _GLIBCXX_HAVE_HYPOT 1


#define _GLIBCXX_HAVE_HYPOTF 1


#define _GLIBCXX_HAVE_HYPOTL 1


#define _GLIBCXX_HAVE_ICONV 1





#define _GLIBCXX_HAVE_INT64_T 1


#define _GLIBCXX_HAVE_INT64_T_LONG 1





#define _GLIBCXX_HAVE_INTTYPES_H 1
# 876 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_ISWBLANK 1


#define _GLIBCXX_HAVE_LC_MESSAGES 1


#define _GLIBCXX_HAVE_LDEXPF 1


#define _GLIBCXX_HAVE_LDEXPL 1





#define _GLIBCXX_HAVE_LIMIT_AS 1


#define _GLIBCXX_HAVE_LIMIT_DATA 1


#define _GLIBCXX_HAVE_LIMIT_FSIZE 1


#define _GLIBCXX_HAVE_LIMIT_RSS 1


#define _GLIBCXX_HAVE_LIMIT_VMEM 0


#define _GLIBCXX_HAVE_LINUX_FUTEX 1


#define _GLIBCXX_HAVE_LOCALE_H 1


#define _GLIBCXX_HAVE_LOG10F 1


#define _GLIBCXX_HAVE_LOG10L 1


#define _GLIBCXX_HAVE_LOGF 1


#define _GLIBCXX_HAVE_LOGL 1
# 930 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_MBSTATE_T 1


#define _GLIBCXX_HAVE_MEMALIGN 1


#define _GLIBCXX_HAVE_MEMORY_H 1


#define _GLIBCXX_HAVE_MODF 1


#define _GLIBCXX_HAVE_MODFF 1


#define _GLIBCXX_HAVE_MODFL 1
# 957 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_POLL 1


#define _GLIBCXX_HAVE_POSIX_MEMALIGN 1


#define _GLIBCXX_HAVE_POWF 1


#define _GLIBCXX_HAVE_POWL 1





#define _GLIBCXX_HAVE_QUICK_EXIT 1





#define _GLIBCXX_HAVE_SINCOS 1


#define _GLIBCXX_HAVE_SINCOSF 1


#define _GLIBCXX_HAVE_SINCOSL 1


#define _GLIBCXX_HAVE_SINF 1


#define _GLIBCXX_HAVE_SINHF 1


#define _GLIBCXX_HAVE_SINHL 1


#define _GLIBCXX_HAVE_SINL 1





#define _GLIBCXX_HAVE_SQRTF 1


#define _GLIBCXX_HAVE_SQRTL 1


#define _GLIBCXX_HAVE_STDALIGN_H 1


#define _GLIBCXX_HAVE_STDBOOL_H 1


#define _GLIBCXX_HAVE_STDINT_H 1


#define _GLIBCXX_HAVE_STDLIB_H 1





#define _GLIBCXX_HAVE_STRERROR_R 1


#define _GLIBCXX_HAVE_STRINGS_H 1


#define _GLIBCXX_HAVE_STRING_H 1


#define _GLIBCXX_HAVE_STRTOF 1


#define _GLIBCXX_HAVE_STRTOLD 1


#define _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE 1






#define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1





#define _GLIBCXX_HAVE_SYS_IOCTL_H 1


#define _GLIBCXX_HAVE_SYS_IPC_H 1
# 1063 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_HAVE_SYS_PARAM_H 1


#define _GLIBCXX_HAVE_SYS_RESOURCE_H 1





#define _GLIBCXX_HAVE_SYS_SEM_H 1


#define _GLIBCXX_HAVE_SYS_STATVFS_H 1


#define _GLIBCXX_HAVE_SYS_STAT_H 1


#define _GLIBCXX_HAVE_SYS_SYSINFO_H 1


#define _GLIBCXX_HAVE_SYS_TIME_H 1


#define _GLIBCXX_HAVE_SYS_TYPES_H 1


#define _GLIBCXX_HAVE_SYS_UIO_H 1





#define _GLIBCXX_HAVE_S_ISREG 1


#define _GLIBCXX_HAVE_TANF 1


#define _GLIBCXX_HAVE_TANHF 1


#define _GLIBCXX_HAVE_TANHL 1


#define _GLIBCXX_HAVE_TANL 1


#define _GLIBCXX_HAVE_TGMATH_H 1


#define _GLIBCXX_HAVE_TLS 1


#define _GLIBCXX_HAVE_UCHAR_H 1


#define _GLIBCXX_HAVE_UNISTD_H 1





#define _GLIBCXX_HAVE_UTIME_H 1


#define _GLIBCXX_HAVE_VFWSCANF 1


#define _GLIBCXX_HAVE_VSWSCANF 1


#define _GLIBCXX_HAVE_VWSCANF 1


#define _GLIBCXX_HAVE_WCHAR_H 1


#define _GLIBCXX_HAVE_WCSTOF 1


#define _GLIBCXX_HAVE_WCTYPE_H 1





#define _GLIBCXX_HAVE_WRITEV 1
# 1348 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_ICONV_CONST 



#define LT_OBJDIR ".libs/"





#define _GLIBCXX_PACKAGE_BUGREPORT ""


#define _GLIBCXX_PACKAGE_NAME "package-unused"


#define _GLIBCXX_PACKAGE_STRING "package-unused version-unused"


#define _GLIBCXX_PACKAGE_TARNAME "libstdc++"


#define _GLIBCXX_PACKAGE_URL ""


#define _GLIBCXX_PACKAGE__GLIBCXX_VERSION "version-unused"
# 1391 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define STDC_HEADERS 1







#define _GLIBCXX11_USE_C99_COMPLEX 1



#define _GLIBCXX11_USE_C99_MATH 1



#define _GLIBCXX11_USE_C99_STDIO 1



#define _GLIBCXX11_USE_C99_STDLIB 1



#define _GLIBCXX11_USE_C99_WCHAR 1




#define _GLIBCXX98_USE_C99_COMPLEX 1



#define _GLIBCXX98_USE_C99_MATH 1



#define _GLIBCXX98_USE_C99_STDIO 1



#define _GLIBCXX98_USE_C99_STDLIB 1



#define _GLIBCXX98_USE_C99_WCHAR 1


#define _GLIBCXX_ATOMIC_BUILTINS 1






#define _GLIBCXX_FULLY_DYNAMIC_STRING 0


#define _GLIBCXX_HAS_GTHREADS 1


#define _GLIBCXX_HOSTED 1




#define _GLIBCXX_MANGLE_SIZE_T m
# 1466 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_RES_LIMITS 1





#define _GLIBCXX_STDIO_EOF -1


#define _GLIBCXX_STDIO_SEEK_CUR 1


#define _GLIBCXX_STDIO_SEEK_END 2


#define _GLIBCXX_SYMVER 1





#define _GLIBCXX_SYMVER_GNU 1
# 1497 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_USE_C11_UCHAR_CXX11 1



#define _GLIBCXX_USE_C99 1




#define _GLIBCXX_USE_C99_COMPLEX_TR1 1



#define _GLIBCXX_USE_C99_CTYPE_TR1 1



#define _GLIBCXX_USE_C99_FENV_TR1 1



#define _GLIBCXX_USE_C99_INTTYPES_TR1 1



#define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1



#define _GLIBCXX_USE_C99_MATH_TR1 1



#define _GLIBCXX_USE_C99_STDINT_TR1 1



#define _GLIBCXX_USE_CLOCK_GETTIME_SYSCALL 1


#define _GLIBCXX_USE_CLOCK_MONOTONIC 1


#define _GLIBCXX_USE_CLOCK_REALTIME 1






#define _GLIBCXX_USE_FCHMOD 1


#define _GLIBCXX_USE_FCHMODAT 1





#define _GLIBCXX_USE_GETTIMEOFDAY 1


#define _GLIBCXX_USE_GET_NPROCS 1


#define _GLIBCXX_USE_INT128 1


#define _GLIBCXX_USE_LFS 1


#define _GLIBCXX_USE_LONG_LONG 1


#define _GLIBCXX_USE_NANOSLEEP 1
# 1580 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++config.h" 3
#define _GLIBCXX_USE_PTHREAD_RWLOCK_T 1



#define _GLIBCXX_USE_RANDOM_TR1 1


#define _GLIBCXX_USE_REALPATH 1


#define _GLIBCXX_USE_SCHED_YIELD 1


#define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1





#define _GLIBCXX_USE_SENDFILE 1


#define _GLIBCXX_USE_ST_MTIM 1





#define _GLIBCXX_USE_TMPNAM 1



#define _GLIBCXX_USE_UTIMENSAT 1


#define _GLIBCXX_USE_WCHAR_T 1


#define _GLIBCXX_VERBOSE 1





#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/initializer_list" 2 3

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
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/array.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/array.h" 3
#define KJ_ARRAY_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/array.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 1 3
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_COMMON_H_ 
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
# 74 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 1 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 3
#define __STDDEF_H 

#define __need_ptrdiff_t 
#define __need_size_t 
#define __need_wchar_t 
#define __need_NULL 
#define __need_STDDEF_H_misc 







#define _PTRDIFF_T 

typedef long int ptrdiff_t;

#undef __need_ptrdiff_t






#define _SIZE_T 

typedef long unsigned int size_t;

#undef __need_size_t
# 93 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 3
#undef __need_wchar_t



#undef NULL


#define NULL __null
# 113 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 3
#undef __need_NULL





# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/__stddef_max_align_t.h" 1 3
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/__stddef_max_align_t.h" 3
#define __CLANG_MAX_ALIGN_T_DEFINED 







typedef struct {
  long long __clang_max_align_nonce1
      __attribute__((__aligned__(__alignof__(long long))));
  long double __clang_max_align_nonce2
      __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
# 119 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 2 3

#define offsetof(t,d) __builtin_offsetof(t, d)
#undef __need_STDDEF_H_misc
# 75 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 2 3
# 94 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
namespace kj {

typedef unsigned int uint;
typedef unsigned char byte;
# 129 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_NDEBUG 





#define KJ_DISALLOW_COPY(classname) classname(const classname&) = delete; classname& operator=(const classname&) = delete





#define KJ_LIKELY(condition) __builtin_expect(condition, true)
#define KJ_UNLIKELY(condition) __builtin_expect(condition, false)
# 158 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_ALWAYS_INLINE(...) inline __VA_ARGS__ __attribute__((always_inline))







#define KJ_NOINLINE __attribute__((noinline))
# 177 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_NORETURN(prototype) prototype __attribute__((noreturn))
#define KJ_UNUSED __attribute__((unused))
#define KJ_WARN_UNUSED_RESULT __attribute__((warn_unused_result))



#define KJ_UNUSED_MEMBER __attribute__((unused))







#define KJ_DEPRECATED(reason) __attribute__((deprecated(reason)))

#define KJ_UNAVAILABLE(reason) __attribute__((unavailable(reason)))
# 205 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
namespace _ {

void inlineRequireFailure( const char* file, int line, const char* expectation, const char* macroArgs, const char* message = nullptr) __attribute__((noreturn));



void unreachable() __attribute__((noreturn));

}
# 234 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_IREQUIRE(condition,...) 


#define KJ_IASSERT KJ_IREQUIRE

#define KJ_UNREACHABLE ::kj::_::unreachable();




#define KJ_CLANG_KNOWS_THIS_IS_UNREACHABLE_BUT_GCC_DOESNT 
# 265 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_STACK_ARRAY(type,name,size,minStack,maxStack) size_t name##_size = (size); bool name##_isOnStack = name##_size <= (minStack); type name##_stack[minStack]; ::kj::Array<type> name##_heap = name##_isOnStack ? nullptr : kj::heapArray<type>(name##_size); ::kj::ArrayPtr<type> name = name##_isOnStack ? kj::arrayPtr(name##_stack, name##_size) : name##_heap
# 275 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_CONCAT_(x,y) x##y
#define KJ_CONCAT(x,y) KJ_CONCAT_(x, y)
#define KJ_UNIQUE_NAME(prefix) KJ_CONCAT(prefix, __LINE__)
# 304 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_CONSTEXPR(...) constexpr





template <typename T> struct NoInfer_ { typedef T Type; };
template <typename T> using NoInfer = typename NoInfer_<T>::Type;



template <typename T> struct RemoveConst_ { typedef T Type; };
template <typename T> struct RemoveConst_<const T> { typedef T Type; };
template <typename T> using RemoveConst = typename RemoveConst_<T>::Type;

template <typename> struct IsLvalueReference_ { static constexpr bool value = false; };
template <typename T> struct IsLvalueReference_<T&> { static constexpr bool value = true; };
template <typename T>
inline constexpr bool isLvalueReference() { return IsLvalueReference_<T>::value; }

template <typename T> struct Decay_ { typedef T Type; };
template <typename T> struct Decay_<T&> { typedef typename Decay_<T>::Type Type; };
template <typename T> struct Decay_<T&&> { typedef typename Decay_<T>::Type Type; };
template <typename T> struct Decay_<T[]> { typedef typename Decay_<T*>::Type Type; };
template <typename T> struct Decay_<const T[]> { typedef typename Decay_<const T*>::Type Type; };
template <typename T, size_t s> struct Decay_<T[s]> { typedef typename Decay_<T*>::Type Type; };
template <typename T, size_t s> struct Decay_<const T[s]> { typedef typename Decay_<const T*>::Type Type; };
template <typename T> struct Decay_<const T> { typedef typename Decay_<T>::Type Type; };
template <typename T> struct Decay_<volatile T> { typedef typename Decay_<T>::Type Type; };
template <typename T> using Decay = typename Decay_<T>::Type;

template <bool b> struct EnableIf_;
template <> struct EnableIf_<true> { typedef void Type; };
template <bool b> using EnableIf = typename EnableIf_<b>::Type;





template <typename...> struct VoidSfinae_ { using Type = void; };
template <typename... Ts> using VoidSfinae = typename VoidSfinae_<Ts...>::Type;


template <typename T>
T instance() noexcept;



struct DisallowConstCopy {
# 385 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
};
# 400 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
#define KJ_CPCAP(obj) obj




template <typename T>
struct DisallowConstCopyIfNotConst: public DisallowConstCopy {



};

template <typename T>
struct DisallowConstCopyIfNotConst<const T> {};

template <typename T> struct IsConst_ { static constexpr bool value = false; };
template <typename T> struct IsConst_<const T> { static constexpr bool value = true; };
template <typename T> constexpr bool isConst() { return IsConst_<T>::value; }

template <typename T> struct EnableIfNotConst_ { typedef T Type; };
template <typename T> struct EnableIfNotConst_<const T>;
template <typename T> using EnableIfNotConst = typename EnableIfNotConst_<T>::Type;

template <typename T> struct EnableIfConst_;
template <typename T> struct EnableIfConst_<const T> { typedef T Type; };
template <typename T> using EnableIfConst = typename EnableIfConst_<T>::Type;

template <typename T> struct RemoveConstOrDisable_ { struct Type; };
template <typename T> struct RemoveConstOrDisable_<const T> { typedef T Type; };
template <typename T> using RemoveConstOrDisable = typename RemoveConstOrDisable_<T>::Type;

template <typename T> struct IsReference_ { static constexpr bool value = false; };
template <typename T> struct IsReference_<T&> { static constexpr bool value = true; };
template <typename T> constexpr bool isReference() { return IsReference_<T>::value; }

template <typename From, typename To>
struct PropagateConst_ { typedef To Type; };
template <typename From, typename To>
struct PropagateConst_<const From, To> { typedef const To Type; };
template <typename From, typename To>
using PropagateConst = typename PropagateConst_<From, To>::Type;

namespace _ {

template <typename T>
T refIfLvalue(T&&);

}

#define KJ_DECLTYPE_REF(exp) decltype(::kj::_::refIfLvalue(exp))








template <typename T>
struct CanConvert_ {
  static int sfinae(T);
  static bool sfinae(...);
};

template <typename T, typename U>
constexpr bool canConvert() {
  return sizeof(CanConvert_<U>::sfinae(instance<T>())) == sizeof(int);
}
# 484 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
template <typename T>
constexpr bool canMemcpy() {



  return __is_trivially_constructible(T, const T&) && __is_trivially_assignable(T, const T&);
}
#define KJ_ASSERT_CAN_MEMCPY(T) static_assert(kj::canMemcpy<T>(), "this code expects this type to be memcpy()-able");
# 503 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
template<typename T> constexpr T&& mv(T& t) noexcept { return static_cast<T&&>(t); }
template<typename T> constexpr T&& fwd(NoInfer<T>& t) noexcept { return static_cast<T&&>(t); }

template<typename T> constexpr T cp(T& t) noexcept { return t; }
template<typename T> constexpr T cp(const T& t) noexcept { return t; }


template <typename T, typename U, bool takeT, bool uOK = true> struct ChooseType_;
template <typename T, typename U> struct ChooseType_<T, U, true, true> { typedef T Type; };
template <typename T, typename U> struct ChooseType_<T, U, true, false> { typedef T Type; };
template <typename T, typename U> struct ChooseType_<T, U, false, true> { typedef U Type; };

template <typename T, typename U>
using WiderType = typename ChooseType_<T, U, sizeof(T) >= sizeof(U)>::Type;

template <typename T, typename U>
inline constexpr auto min(T&& a, U&& b) -> WiderType<Decay<T>, Decay<U>> {
  return a < b ? WiderType<Decay<T>, Decay<U>>(a) : WiderType<Decay<T>, Decay<U>>(b);
}

template <typename T, typename U>
inline constexpr auto max(T&& a, U&& b) -> WiderType<Decay<T>, Decay<U>> {
  return a > b ? WiderType<Decay<T>, Decay<U>>(a) : WiderType<Decay<T>, Decay<U>>(b);
}

template <typename T, size_t s>
inline constexpr size_t size(T (&arr)[s]) { return s; }
template <typename T>
inline constexpr size_t size(T&& arr) { return arr.size(); }



class MaxValue_ {
private:
  template <typename T>
  inline constexpr T maxSigned() const {
    return (1ull << (sizeof(T) * 8 - 1)) - 1;
  }
  template <typename T>
  inline constexpr T maxUnsigned() const {
    return ~static_cast<T>(0u);
  }

public:
#define _kJ_HANDLE_TYPE(T) inline constexpr operator signed T() const { return MaxValue_::maxSigned < signed T>(); } inline constexpr operator unsigned T() const { return MaxValue_::maxUnsigned<unsigned T>(); }


 inline constexpr operator signed char() const { return MaxValue_::maxSigned < signed char>(); } inline constexpr operator unsigned char() const { return MaxValue_::maxUnsigned<unsigned char>(); }
  inline constexpr operator signed short() const { return MaxValue_::maxSigned < signed short>(); } inline constexpr operator unsigned short() const { return MaxValue_::maxUnsigned<unsigned short>(); }
  inline constexpr operator signed int() const { return MaxValue_::maxSigned < signed int>(); } inline constexpr operator unsigned int() const { return MaxValue_::maxUnsigned<unsigned int>(); }
  inline constexpr operator signed long() const { return MaxValue_::maxSigned < signed long>(); } inline constexpr operator unsigned long() const { return MaxValue_::maxUnsigned<unsigned long>(); }
  inline constexpr operator signed long long() const { return MaxValue_::maxSigned < signed long long>(); } inline constexpr operator unsigned long long() const { return MaxValue_::maxUnsigned<unsigned long long>(); }
#undef _kJ_HANDLE_TYPE

 inline constexpr operator char() const {


    return char(-1) < 0 ? MaxValue_::maxSigned<char>()
                        : MaxValue_::maxUnsigned<char>();
  }
};

class MinValue_ {
private:
  template <typename T>
  inline constexpr T minSigned() const {
    return 1ull << (sizeof(T) * 8 - 1);
  }
  template <typename T>
  inline constexpr T minUnsigned() const {
    return 0u;
  }

public:
#define _kJ_HANDLE_TYPE(T) inline constexpr operator signed T() const { return MinValue_::minSigned < signed T>(); } inline constexpr operator unsigned T() const { return MinValue_::minUnsigned<unsigned T>(); }


 inline constexpr operator signed char() const { return MinValue_::minSigned < signed char>(); } inline constexpr operator unsigned char() const { return MinValue_::minUnsigned<unsigned char>(); }
  inline constexpr operator signed short() const { return MinValue_::minSigned < signed short>(); } inline constexpr operator unsigned short() const { return MinValue_::minUnsigned<unsigned short>(); }
  inline constexpr operator signed int() const { return MinValue_::minSigned < signed int>(); } inline constexpr operator unsigned int() const { return MinValue_::minUnsigned<unsigned int>(); }
  inline constexpr operator signed long() const { return MinValue_::minSigned < signed long>(); } inline constexpr operator unsigned long() const { return MinValue_::minUnsigned<unsigned long>(); }
  inline constexpr operator signed long long() const { return MinValue_::minSigned < signed long long>(); } inline constexpr operator unsigned long long() const { return MinValue_::minUnsigned<unsigned long long>(); }
#undef _kJ_HANDLE_TYPE

 inline constexpr operator char() const {


    return char(-1) < 0 ? MinValue_::minSigned<char>()
                        : MinValue_::minUnsigned<char>();
  }
};

static constexpr MaxValue_ maxValue = MaxValue_();






static constexpr MinValue_ minValue = MinValue_();






template <typename T>
inline bool operator==(T t, MaxValue_) { return t == Decay<T>(maxValue); }
template <typename T>
inline bool operator==(T t, MinValue_) { return t == Decay<T>(minValue); }

template <uint bits>
inline constexpr unsigned long long maxValueForBits() {



  return (bits == 64 ? 0 : (1ull << bits)) - 1;
}

struct ThrowOverflow {



  void operator()() const;
};


inline constexpr float inf() { return __builtin_huge_valf(); }
inline constexpr float nan() { return __builtin_nanf(""); }
# 653 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
inline constexpr bool isNaN(float f) { return f != f; }
inline constexpr bool isNaN(double f) { return f != f; }

inline int popCount(unsigned int x) {




  return __builtin_popcount(x);

}




template <typename T>
class Range {
public:
  inline constexpr Range(const T& begin, const T& end): begin_(begin), end_(end) {}
  inline explicit constexpr Range(const T& end): begin_(0), end_(end) {}

  class Iterator {
  public:
    Iterator() = default;
    inline Iterator(const T& value): value(value) {}

    inline const T& operator* () const { return value; }
    inline const T& operator[](size_t index) const { return value + index; }
    inline Iterator& operator++() { ++value; return *this; }
    inline Iterator operator++(int) { return Iterator(value++); }
    inline Iterator& operator--() { --value; return *this; }
    inline Iterator operator--(int) { return Iterator(value--); }
    inline Iterator& operator+=(ptrdiff_t amount) { value += amount; return *this; }
    inline Iterator& operator-=(ptrdiff_t amount) { value -= amount; return *this; }
    inline Iterator operator+ (ptrdiff_t amount) const { return Iterator(value + amount); }
    inline Iterator operator- (ptrdiff_t amount) const { return Iterator(value - amount); }
    inline ptrdiff_t operator- (const Iterator& other) const { return value - other.value; }

    inline bool operator==(const Iterator& other) const { return value == other.value; }
    inline bool operator!=(const Iterator& other) const { return value != other.value; }
    inline bool operator<=(const Iterator& other) const { return value <= other.value; }
    inline bool operator>=(const Iterator& other) const { return value >= other.value; }
    inline bool operator< (const Iterator& other) const { return value < other.value; }
    inline bool operator> (const Iterator& other) const { return value > other.value; }

  private:
    T value;
  };

  inline Iterator begin() const { return Iterator(begin_); }
  inline Iterator end() const { return Iterator(end_); }

  inline auto size() const -> decltype(instance<T>() - instance<T>()) { return end_ - begin_; }

private:
  T begin_;
  T end_;
};

template <typename T, typename U>
inline constexpr Range<WiderType<Decay<T>, Decay<U>>> range(T begin, U end) {
  return Range<WiderType<Decay<T>, Decay<U>>>(begin, end);
}

template <typename T>
inline constexpr Range<Decay<T>> range(T begin, T end) { return Range<Decay<T>>(begin, end); }






template <typename T>
inline constexpr Range<Decay<T>> zeroTo(T end) { return Range<Decay<T>>(end); }






template <typename T>
inline constexpr Range<size_t> indices(T&& container) {




  return range<size_t>(0, kj::size(container));
}

template <typename T>
class Repeat {
public:
  inline constexpr Repeat(const T& value, size_t count): value(value), count(count) {}

  class Iterator {
  public:
    Iterator() = default;
    inline Iterator(const T& value, size_t index): value(value), index(index) {}

    inline const T& operator* () const { return value; }
    inline const T& operator[](ptrdiff_t index) const { return value; }
    inline Iterator& operator++() { ++index; return *this; }
    inline Iterator operator++(int) { return Iterator(value, index++); }
    inline Iterator& operator--() { --index; return *this; }
    inline Iterator operator--(int) { return Iterator(value, index--); }
    inline Iterator& operator+=(ptrdiff_t amount) { index += amount; return *this; }
    inline Iterator& operator-=(ptrdiff_t amount) { index -= amount; return *this; }
    inline Iterator operator+ (ptrdiff_t amount) const { return Iterator(value, index + amount); }
    inline Iterator operator- (ptrdiff_t amount) const { return Iterator(value, index - amount); }
    inline ptrdiff_t operator- (const Iterator& other) const { return index - other.index; }

    inline bool operator==(const Iterator& other) const { return index == other.index; }
    inline bool operator!=(const Iterator& other) const { return index != other.index; }
    inline bool operator<=(const Iterator& other) const { return index <= other.index; }
    inline bool operator>=(const Iterator& other) const { return index >= other.index; }
    inline bool operator< (const Iterator& other) const { return index < other.index; }
    inline bool operator> (const Iterator& other) const { return index > other.index; }

  private:
    T value;
    size_t index;
  };

  inline Iterator begin() const { return Iterator(value, 0); }
  inline Iterator end() const { return Iterator(value, count); }

  inline size_t size() const { return count; }
  inline const T& operator[](ptrdiff_t) const { return value; }

private:
  T value;
  size_t count;
};

template <typename T>
inline constexpr Repeat<Decay<T>> repeat(T&& value, size_t count) {



  return Repeat<Decay<T>>(value, count);
}
# 804 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
namespace _ {
struct PlacementNew {};
}
}

inline void* operator new(size_t, kj::_::PlacementNew, void* __p) noexcept {
  return __p;
}

inline void operator delete(void*, kj::_::PlacementNew, void* __p) noexcept {}

namespace kj {

template <typename T, typename... Params>
inline void ctor(T& location, Params&&... params) {
  new (_::PlacementNew(), &location) T(kj::fwd<Params>(params)...);
}

template <typename T>
inline void dtor(T& location) {
  location.~T();
}
# 851 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
template <typename T>
class Maybe;

namespace _ {

template <typename T>
class NullableValue {



public:
  inline NullableValue(NullableValue&& other) noexcept(noexcept(T(instance<T&&>())))
      : isSet(other.isSet) {
    if (isSet) {
      ctor(value, kj::mv(other.value));
    }
  }
  inline NullableValue(const NullableValue& other)
      : isSet(other.isSet) {
    if (isSet) {
      ctor(value, other.value);
    }
  }
  inline NullableValue(NullableValue& other)
      : isSet(other.isSet) {
    if (isSet) {
      ctor(value, other.value);
    }
  }
  inline ~NullableValue()





      noexcept(noexcept(instance<T&>().~T()))

  {
    if (isSet) {
      dtor(value);
    }
  }

  inline T& operator*() & { return value; }
  inline const T& operator*() const & { return value; }
  inline T&& operator*() && { return kj::mv(value); }
  inline const T&& operator*() const && { return kj::mv(value); }
  inline T* operator->() { return &value; }
  inline const T* operator->() const { return &value; }
  inline operator T*() { return isSet ? &value : nullptr; }
  inline operator const T*() const { return isSet ? &value : nullptr; }

  template <typename... Params>
  inline T& emplace(Params&&... params) {
    if (isSet) {
      isSet = false;
      dtor(value);
    }
    ctor(value, kj::fwd<Params>(params)...);
    isSet = true;
    return value;
  }

private:
  inline NullableValue() noexcept: isSet(false) {}
  inline NullableValue(T&& t) noexcept(noexcept(T(instance<T&&>())))
      : isSet(true) {
    ctor(value, kj::mv(t));
  }
  inline NullableValue(T& t)
      : isSet(true) {
    ctor(value, t);
  }
  inline NullableValue(const T& t)
      : isSet(true) {
    ctor(value, t);
  }
  inline NullableValue(const T* t)
      : isSet(t != nullptr) {
    if (isSet) ctor(value, *t);
  }
  template <typename U>
  inline NullableValue(NullableValue<U>&& other) noexcept(noexcept(T(instance<U&&>())))
      : isSet(other.isSet) {
    if (isSet) {
      ctor(value, kj::mv(other.value));
    }
  }
  template <typename U>
  inline NullableValue(const NullableValue<U>& other)
      : isSet(other.isSet) {
    if (isSet) {
      ctor(value, other.value);
    }
  }
  template <typename U>
  inline NullableValue(const NullableValue<U&>& other)
      : isSet(other.isSet) {
    if (isSet) {
      ctor(value, *other.ptr);
    }
  }
  inline NullableValue(decltype(nullptr)): isSet(false) {}

  inline NullableValue& operator=(NullableValue&& other) {
    if (&other != this) {

      if (isSet) {
        isSet = false;
        dtor(value);
      }
      if (other.isSet) {
        ctor(value, kj::mv(other.value));
        isSet = true;
      }
    }
    return *this;
  }

  inline NullableValue& operator=(NullableValue& other) {
    if (&other != this) {

      if (isSet) {
        isSet = false;
        dtor(value);
      }
      if (other.isSet) {
        ctor(value, other.value);
        isSet = true;
      }
    }
    return *this;
  }

  inline NullableValue& operator=(const NullableValue& other) {
    if (&other != this) {

      if (isSet) {
        isSet = false;
        dtor(value);
      }
      if (other.isSet) {
        ctor(value, other.value);
        isSet = true;
      }
    }
    return *this;
  }

  inline bool operator==(decltype(nullptr)) const { return !isSet; }
  inline bool operator!=(decltype(nullptr)) const { return isSet; }

private:
  bool isSet;
# 1013 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
  union {
    T value;
  };





  friend class kj::Maybe<T>;
  template <typename U>
  friend NullableValue<U>&& readMaybe(Maybe<U>&& maybe);
};

template <typename T>
inline NullableValue<T>&& readMaybe(Maybe<T>&& maybe) { return kj::mv(maybe.ptr); }
template <typename T>
inline T* readMaybe(Maybe<T>& maybe) { return maybe.ptr; }
template <typename T>
inline const T* readMaybe(const Maybe<T>& maybe) { return maybe.ptr; }
template <typename T>
inline T* readMaybe(Maybe<T&>&& maybe) { return maybe.ptr; }
template <typename T>
inline T* readMaybe(const Maybe<T&>& maybe) { return maybe.ptr; }

template <typename T>
inline T* readMaybe(T* ptr) { return ptr; }


}

#define KJ_IF_MAYBE(name,exp) if (auto name = ::kj::_::readMaybe(exp))

template <typename T>
class Maybe {




public:
  Maybe(): ptr(nullptr) {}
  Maybe(T&& t) noexcept(noexcept(T(instance<T&&>()))): ptr(kj::mv(t)) {}
  Maybe(T& t): ptr(t) {}
  Maybe(const T& t): ptr(t) {}
  Maybe(const T* t) noexcept: ptr(t) {}
  Maybe(Maybe&& other) noexcept(noexcept(T(instance<T&&>()))): ptr(kj::mv(other.ptr)) {}
  Maybe(const Maybe& other): ptr(other.ptr) {}
  Maybe(Maybe& other): ptr(other.ptr) {}

  template <typename U>
  Maybe(Maybe<U>&& other) noexcept(noexcept(T(instance<U&&>()))) {
    if (auto val = ::kj::_::readMaybe(kj::mv(other))) {
      ptr.emplace(kj::mv(*val));
    }
  }
  template <typename U>
  Maybe(const Maybe<U>& other) {
    if (auto val = ::kj::_::readMaybe(other)) {
      ptr.emplace(*val);
    }
  }

  Maybe(decltype(nullptr)) noexcept: ptr(nullptr) {}

  template <typename... Params>
  inline T& emplace(Params&&... params) {




    return ptr.emplace(kj::fwd<Params>(params)...);
  }

  inline Maybe& operator=(Maybe&& other) { ptr = kj::mv(other.ptr); return *this; }
  inline Maybe& operator=(Maybe& other) { ptr = other.ptr; return *this; }
  inline Maybe& operator=(const Maybe& other) { ptr = other.ptr; return *this; }

  inline bool operator==(decltype(nullptr)) const { return ptr == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return ptr != nullptr; }

  T& orDefault(T& defaultValue) {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return *ptr;
    }
  }
  const T& orDefault(const T& defaultValue) const {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return *ptr;
    }
  }

  template <typename Func>
  auto map(Func&& f) & -> Maybe<decltype(f(instance<T&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(*ptr);
    }
  }

  template <typename Func>
  auto map(Func&& f) const & -> Maybe<decltype(f(instance<const T&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(*ptr);
    }
  }

  template <typename Func>
  auto map(Func&& f) && -> Maybe<decltype(f(instance<T&&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(kj::mv(*ptr));
    }
  }

  template <typename Func>
  auto map(Func&& f) const && -> Maybe<decltype(f(instance<const T&&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(kj::mv(*ptr));
    }
  }

private:
  _::NullableValue<T> ptr;

  template <typename U>
  friend class Maybe;
  template <typename U>
  friend _::NullableValue<U>&& _::readMaybe(Maybe<U>&& maybe);
  template <typename U>
  friend U* _::readMaybe(Maybe<U>& maybe);
  template <typename U>
  friend const U* _::readMaybe(const Maybe<U>& maybe);
};

template <typename T>
class Maybe<T&>: public DisallowConstCopyIfNotConst<T> {
public:
  Maybe() noexcept: ptr(nullptr) {}
  Maybe(T& t) noexcept: ptr(&t) {}
  Maybe(T* t) noexcept: ptr(t) {}

  template <typename U>
  inline Maybe(Maybe<U&>& other) noexcept: ptr(other.ptr) {}
  template <typename U>
  inline Maybe(const Maybe<const U&>& other) noexcept: ptr(other.ptr) {}
  inline Maybe(decltype(nullptr)) noexcept: ptr(nullptr) {}

  inline Maybe& operator=(T& other) noexcept { ptr = &other; return *this; }
  inline Maybe& operator=(T* other) noexcept { ptr = other; return *this; }
  template <typename U>
  inline Maybe& operator=(Maybe<U&>& other) noexcept { ptr = other.ptr; return *this; }
  template <typename U>
  inline Maybe& operator=(const Maybe<const U&>& other) noexcept { ptr = other.ptr; return *this; }

  inline bool operator==(decltype(nullptr)) const { return ptr == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return ptr != nullptr; }

  T& orDefault(T& defaultValue) {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return *ptr;
    }
  }
  const T& orDefault(const T& defaultValue) const {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return *ptr;
    }
  }

  template <typename Func>
  auto map(Func&& f) -> Maybe<decltype(f(instance<T&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(*ptr);
    }
  }

private:
  T* ptr;

  template <typename U>
  friend class Maybe;
  template <typename U>
  friend U* _::readMaybe(Maybe<U&>&& maybe);
  template <typename U>
  friend U* _::readMaybe(const Maybe<U&>& maybe);
};






template <typename T>
class ArrayPtr: public DisallowConstCopyIfNotConst<T> {



public:
  inline constexpr ArrayPtr(): ptr(nullptr), size_(0) {}
  inline constexpr ArrayPtr(decltype(nullptr)): ptr(nullptr), size_(0) {}
  inline constexpr ArrayPtr(T* ptr, size_t size): ptr(ptr), size_(size) {}
  inline constexpr ArrayPtr(T* begin, T* end): ptr(begin), size_(end - begin) {}
  inline constexpr ArrayPtr(::std::initializer_list<RemoveConstOrDisable<T>> init)
      : ptr(init.begin()), size_(init.size()) {}

  template <size_t size>
  inline constexpr ArrayPtr(T (&native)[size]): ptr(native), size_(size) {}


  inline operator ArrayPtr<const T>() const {
    return ArrayPtr<const T>(ptr, size_);
  }
  inline ArrayPtr<const T> asConst() const {
    return ArrayPtr<const T>(ptr, size_);
  }

  inline size_t size() const { return size_; }
  inline const T& operator[](size_t index) const {
                                                                ;
    return ptr[index];
  }
  inline T& operator[](size_t index) {
                                                                ;
    return ptr[index];
  }

  inline T* begin() { return ptr; }
  inline T* end() { return ptr + size_; }
  inline T& front() { return *ptr; }
  inline T& back() { return *(ptr + size_ - 1); }
  inline const T* begin() const { return ptr; }
  inline const T* end() const { return ptr + size_; }
  inline const T& front() const { return *ptr; }
  inline const T& back() const { return *(ptr + size_ - 1); }

  inline ArrayPtr<const T> slice(size_t start, size_t end) const {
                                                                                 ;
    return ArrayPtr<const T>(ptr + start, end - start);
  }
  inline ArrayPtr slice(size_t start, size_t end) {
                                                                                 ;
    return ArrayPtr(ptr + start, end - start);
  }

  inline ArrayPtr<PropagateConst<T, byte>> asBytes() const {


    return { reinterpret_cast<PropagateConst<T, byte>*>(ptr), size_ * sizeof(T) };
  }
  inline ArrayPtr<PropagateConst<T, char>> asChars() const {


    return { reinterpret_cast<PropagateConst<T, char>*>(ptr), size_ * sizeof(T) };
  }

  inline bool operator==(decltype(nullptr)) const { return size_ == 0; }
  inline bool operator!=(decltype(nullptr)) const { return size_ != 0; }

  inline bool operator==(const ArrayPtr& other) const {
    if (size_ != other.size_) return false;
    for (size_t i = 0; i < size_; i++) {
      if (ptr[i] != other[i]) return false;
    }
    return true;
  }
  inline bool operator!=(const ArrayPtr& other) const { return !(*this == other); }

private:
  T* ptr;
  size_t size_;
};

template <typename T>
inline constexpr ArrayPtr<T> arrayPtr(T* ptr, size_t size) {

  return ArrayPtr<T>(ptr, size);
}

template <typename T>
inline constexpr ArrayPtr<T> arrayPtr(T* begin, T* end) {

  return ArrayPtr<T>(begin, end);
}




template <typename To, typename From>
To implicitCast(From&& from) {


  return kj::fwd<From>(from);
}

template <typename To, typename From>
Maybe<To&> dynamicDowncastIfAvailable(From& from) {
# 1331 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/common.h" 3
  if (false) {
    kj::implicitCast<From*>(kj::implicitCast<To*>(nullptr));
  }




  return dynamic_cast<To*>(&from);

}

template <typename To, typename From>
To& downcast(From& from) {





  if (false) {
    kj::implicitCast<From*>(kj::implicitCast<To*>(nullptr));
  }


                                                                                                   ;


  return static_cast<To&>(from);
}




namespace _ {

template <typename Func>
class Deferred {
public:
  inline Deferred(Func&& func): func(kj::fwd<Func>(func)), canceled(false) {}
  inline ~Deferred() noexcept(false) { if (!canceled) func(); }
  Deferred(const Deferred&) = delete; Deferred& operator=(const Deferred&) = delete;


  inline Deferred(Deferred&& other): func(kj::mv(other.func)), canceled(false) {
    other.canceled = true;
  }
private:
  Func func;
  bool canceled;
};

}

template <typename Func>
_::Deferred<Func> defer(Func&& func) {







  return _::Deferred<Func>(kj::fwd<Func>(func));
}

#define KJ_DEFER(code) auto KJ_UNIQUE_NAME(_kjDefer) = ::kj::defer([&](){code;})


}
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/array.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/string.h" 1 3 4

#define _STRING_H 


extern "C" {





#define NULL 0L




#define __NEED_size_t 



#define __NEED_locale_t 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 104 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long size_t;
#define __DEFINED_size_t 
# 371 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef struct __locale_struct * locale_t;
#define __DEFINED_locale_t 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 24 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/string.h" 2 3 4

void *memcpy (void *__restrict, const void *__restrict, size_t);
void *memmove (void *, const void *, size_t);
void *memset (void *, int, size_t);
int memcmp (const void *, const void *, size_t);
void *memchr (const void *, int, size_t);

char *strcpy (char *__restrict, const char *__restrict);
char *strncpy (char *__restrict, const char *__restrict, size_t);

char *strcat (char *__restrict, const char *__restrict);
char *strncat (char *__restrict, const char *__restrict, size_t);

int strcmp (const char *, const char *);
int strncmp (const char *, const char *, size_t);

int strcoll (const char *, const char *);
size_t strxfrm (char *__restrict, const char *__restrict, size_t);

char *strchr (const char *, int);
char *strrchr (const char *, int);

size_t strcspn (const char *, const char *);
size_t strspn (const char *, const char *);
char *strpbrk (const char *, const char *);
char *strstr (const char *, const char *);
char *strtok (char *__restrict, const char *__restrict);

size_t strlen (const char *);

char *strerror (int);



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/strings.h" 1 3 4

#define _STRINGS_H 


extern "C" {



#define __NEED_size_t 
#define __NEED_locale_t 

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 12 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/strings.h" 2 3 4




int bcmp (const void *, const void *, size_t);
void bcopy (const void *, void *, size_t);
void bzero (void *, size_t);
char *index (const char *, int);
char *rindex (const char *, int);



int ffs (int);
int ffsl (long);
int ffsll (long long);


int strcasecmp (const char *, const char *);
int strncasecmp (const char *, const char *, size_t);

int strcasecmp_l (const char *, const char *, locale_t);
int strncasecmp_l (const char *, const char *, size_t, locale_t);


}
# 58 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/string.h" 2 3 4





char *strtok_r (char *__restrict, const char *__restrict, char **__restrict);
int strerror_r (int, char *, size_t);
char *stpcpy(char *__restrict, const char *__restrict);
char *stpncpy(char *__restrict, const char *__restrict, size_t);
size_t strnlen (const char *, size_t);
char *strdup (const char *);
char *strndup (const char *, size_t);
char *strsignal(int);
char *strerror_l (int, locale_t);
int strcoll_l (const char *, const char *, locale_t);
size_t strxfrm_l (char *__restrict, const char *__restrict, size_t, locale_t);




void *memccpy (void *__restrict, const void *__restrict, int, size_t);



char *strsep(char **, const char *);
size_t strlcat (char *, const char *, size_t);
size_t strlcpy (char *, const char *, size_t);



#define strdupa(x) strcpy(alloca(strlen(x)+1),x)
int strverscmp (const char *, const char *);
char *strchrnul(const char *, int);
char *strcasestr(const char *, const char *);
void *memmem(const void *, size_t, const void *, size_t);
void *memrchr(const void *, int, size_t);
void *mempcpy(void *, const void *, size_t);






}
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/array.h" 2 3


namespace kj {




class ArrayDisposer {


protected:



  virtual void disposeImpl(void* firstElement, size_t elementSize, size_t elementCount,
                           size_t capacity, void (*destroyElement)(void*)) const = 0;





public:

  template <typename T>
  void dispose(T* firstElement, size_t elementCount, size_t capacity) const;





private:
  template <typename T, bool hasTrivialDestructor = __has_trivial_destructor(T)>
  struct Dispose_;
};

class ExceptionSafeArrayUtil {







public:
  inline ExceptionSafeArrayUtil(void* ptr, size_t elementSize, size_t constructedElementCount,
                                void (*destroyElement)(void*))
      : pos(reinterpret_cast<byte*>(ptr) + elementSize * constructedElementCount),
        elementSize(elementSize), constructedElementCount(constructedElementCount),
        destroyElement(destroyElement) {}
  ExceptionSafeArrayUtil(const ExceptionSafeArrayUtil&) = delete; ExceptionSafeArrayUtil& operator=(const ExceptionSafeArrayUtil&) = delete;

  inline ~ExceptionSafeArrayUtil() noexcept(false) {
    if (constructedElementCount > 0) destroyAll();
  }

  void construct(size_t count, void (*constructElement)(void*));


  void destroyAll();




  void release() { constructedElementCount = 0; }



private:
  byte* pos;
  size_t elementSize;
  size_t constructedElementCount;
  void (*destroyElement)(void*);
};

class DestructorOnlyArrayDisposer: public ArrayDisposer {
public:
  static const DestructorOnlyArrayDisposer instance;

  void disposeImpl(void* firstElement, size_t elementSize, size_t elementCount,
                   size_t capacity, void (*destroyElement)(void*)) const override;
};

class NullArrayDisposer: public ArrayDisposer {



public:
  static const NullArrayDisposer instance;

  void disposeImpl(void* firstElement, size_t elementSize, size_t elementCount,
                   size_t capacity, void (*destroyElement)(void*)) const override;
};




template <typename T>
class Array {




public:
  inline Array(): ptr(nullptr), size_(0), disposer(nullptr) {}
  inline Array(decltype(nullptr)): ptr(nullptr), size_(0), disposer(nullptr) {}
  inline Array(Array&& other) noexcept
      : ptr(other.ptr), size_(other.size_), disposer(other.disposer) {
    other.ptr = nullptr;
    other.size_ = 0;
  }
  inline Array(Array<RemoveConstOrDisable<T>>&& other) noexcept
      : ptr(other.ptr), size_(other.size_), disposer(other.disposer) {
    other.ptr = nullptr;
    other.size_ = 0;
  }
  inline Array(T* firstElement, size_t size, const ArrayDisposer& disposer)
      : ptr(firstElement), size_(size), disposer(&disposer) {}

  Array(const Array&) = delete; Array& operator=(const Array&) = delete;
  inline ~Array() noexcept { dispose(); }

  inline operator ArrayPtr<T>() {
    return ArrayPtr<T>(ptr, size_);
  }
  inline operator ArrayPtr<const T>() const {
    return ArrayPtr<T>(ptr, size_);
  }
  inline ArrayPtr<T> asPtr() {
    return ArrayPtr<T>(ptr, size_);
  }
  inline ArrayPtr<const T> asPtr() const {
    return ArrayPtr<T>(ptr, size_);
  }

  inline size_t size() const { return size_; }
  inline T& operator[](size_t index) const {
                                                             ;
    return ptr[index];
  }

  inline const T* begin() const { return ptr; }
  inline const T* end() const { return ptr + size_; }
  inline const T& front() const { return *ptr; }
  inline const T& back() const { return *(ptr + size_ - 1); }
  inline T* begin() { return ptr; }
  inline T* end() { return ptr + size_; }
  inline T& front() { return *ptr; }
  inline T& back() { return *(ptr + size_ - 1); }

  inline ArrayPtr<T> slice(size_t start, size_t end) {
                                                                              ;
    return ArrayPtr<T>(ptr + start, end - start);
  }
  inline ArrayPtr<const T> slice(size_t start, size_t end) const {
                                                                              ;
    return ArrayPtr<const T>(ptr + start, end - start);
  }

  inline ArrayPtr<const byte> asBytes() const { return asPtr().asBytes(); }
  inline ArrayPtr<PropagateConst<T, byte>> asBytes() { return asPtr().asBytes(); }
  inline ArrayPtr<const char> asChars() const { return asPtr().asChars(); }
  inline ArrayPtr<PropagateConst<T, char>> asChars() { return asPtr().asChars(); }

  inline Array<PropagateConst<T, byte>> releaseAsBytes() {

    static_assert(sizeof(T) == sizeof(byte),
        "releaseAsBytes() only possible on arrays with byte-size elements (e.g. chars).");
    Array<PropagateConst<T, byte>> result(
        reinterpret_cast<PropagateConst<T, byte>*>(ptr), size_, *disposer);
    ptr = nullptr;
    size_ = 0;
    return result;
  }
  inline Array<PropagateConst<T, char>> releaseAsChars() {

    static_assert(sizeof(T) == sizeof(PropagateConst<T, char>),
        "releaseAsChars() only possible on arrays with char-size elements (e.g. bytes).");
    Array<PropagateConst<T, char>> result(
        reinterpret_cast<PropagateConst<T, char>*>(ptr), size_, *disposer);
    ptr = nullptr;
    size_ = 0;
    return result;
  }

  inline bool operator==(decltype(nullptr)) const { return size_ == 0; }
  inline bool operator!=(decltype(nullptr)) const { return size_ != 0; }

  inline Array& operator=(decltype(nullptr)) {
    dispose();
    return *this;
  }

  inline Array& operator=(Array&& other) {
    dispose();
    ptr = other.ptr;
    size_ = other.size_;
    disposer = other.disposer;
    other.ptr = nullptr;
    other.size_ = 0;
    return *this;
  }

private:
  T* ptr;
  size_t size_;
  const ArrayDisposer* disposer;

  inline void dispose() {


    T* ptrCopy = ptr;
    size_t sizeCopy = size_;
    if (ptrCopy != nullptr) {
      ptr = nullptr;
      size_ = 0;
      disposer->dispose(ptrCopy, sizeCopy, sizeCopy);
    }
  }

  template <typename U>
  friend class Array;
};

static_assert(!canMemcpy<Array<char>>(), "canMemcpy<>() is broken");

namespace _ {

class HeapArrayDisposer final: public ArrayDisposer {
public:
  template <typename T>
  static T* allocate(size_t count);
  template <typename T>
  static T* allocateUninitialized(size_t count);

  static const HeapArrayDisposer instance;

private:
  static void* allocateImpl(size_t elementSize, size_t elementCount, size_t capacity,
                            void (*constructElement)(void*), void (*destroyElement)(void*));



  virtual void disposeImpl(void* firstElement, size_t elementSize, size_t elementCount,
                           size_t capacity, void (*destroyElement)(void*)) const override;

  template <typename T, bool hasTrivialConstructor = __has_trivial_constructor(T),
                        bool hasNothrowConstructor = __has_nothrow_constructor(T)>
  struct Allocate_;
};

}

template <typename T>
inline Array<T> heapArray(size_t size) {


  return Array<T>(_::HeapArrayDisposer::allocate<T>(size), size,
                  _::HeapArrayDisposer::instance);
}

template <typename T> Array<T> heapArray(const T* content, size_t size);
template <typename T> Array<T> heapArray(ArrayPtr<T> content);
template <typename T> Array<T> heapArray(ArrayPtr<const T> content);
template <typename T, typename Iterator> Array<T> heapArray(Iterator begin, Iterator end);
template <typename T> Array<T> heapArray(std::initializer_list<T> init);


template <typename T, typename Container>
Array<T> heapArrayFromIterable(Container&& a) { return heapArray<T>(a.begin(), a.end()); }
template <typename T>
Array<T> heapArrayFromIterable(Array<T>&& a) { return mv(a); }




template <typename T>
class ArrayBuilder {



public:
  ArrayBuilder(): ptr(nullptr), pos(nullptr), endPtr(nullptr) {}
  ArrayBuilder(decltype(nullptr)): ptr(nullptr), pos(nullptr), endPtr(nullptr) {}
  explicit ArrayBuilder(RemoveConst<T>* firstElement, size_t capacity,
                        const ArrayDisposer& disposer)
      : ptr(firstElement), pos(firstElement), endPtr(firstElement + capacity),
        disposer(&disposer) {}
  ArrayBuilder(ArrayBuilder&& other)
      : ptr(other.ptr), pos(other.pos), endPtr(other.endPtr), disposer(other.disposer) {
    other.ptr = nullptr;
    other.pos = nullptr;
    other.endPtr = nullptr;
  }
  ArrayBuilder(const ArrayBuilder&) = delete; ArrayBuilder& operator=(const ArrayBuilder&) = delete;
  inline ~ArrayBuilder() noexcept(false) { dispose(); }

  inline operator ArrayPtr<T>() {
    return arrayPtr(ptr, pos);
  }
  inline operator ArrayPtr<const T>() const {
    return arrayPtr(ptr, pos);
  }
  inline ArrayPtr<T> asPtr() {
    return arrayPtr(ptr, pos);
  }
  inline ArrayPtr<const T> asPtr() const {
    return arrayPtr(ptr, pos);
  }

  inline size_t size() const { return pos - ptr; }
  inline size_t capacity() const { return endPtr - ptr; }
  inline T& operator[](size_t index) const {
                                                                                       ;
    return ptr[index];
  }

  inline const T* begin() const { return ptr; }
  inline const T* end() const { return pos; }
  inline const T& front() const { return *ptr; }
  inline const T& back() const { return *(pos - 1); }
  inline T* begin() { return ptr; }
  inline T* end() { return pos; }
  inline T& front() { return *ptr; }
  inline T& back() { return *(pos - 1); }

  ArrayBuilder& operator=(ArrayBuilder&& other) {
    dispose();
    ptr = other.ptr;
    pos = other.pos;
    endPtr = other.endPtr;
    disposer = other.disposer;
    other.ptr = nullptr;
    other.pos = nullptr;
    other.endPtr = nullptr;
    return *this;
  }
  ArrayBuilder& operator=(decltype(nullptr)) {
    dispose();
    return *this;
  }

  template <typename... Params>
  T& add(Params&&... params) {
                                                                         ;
    ctor(*pos, kj::fwd<Params>(params)...);
    return *pos++;
  }

  template <typename Container>
  void addAll(Container&& container) {
    addAll<decltype(container.begin()), !isReference<Container>()>(
        container.begin(), container.end());
  }

  template <typename Iterator, bool move = false>
  void addAll(Iterator start, Iterator end);

  void removeLast() {
                                                            ;
    kj::dtor(*--pos);
  }

  void truncate(size_t size) {
                                                                       ;

    T* target = ptr + size;
    if (__has_trivial_destructor(T)) {
      pos = target;
    } else {
      while (pos > target) {
        kj::dtor(*--pos);
      }
    }
  }

  void resize(size_t size) {
                                                                 ;

    T* target = ptr + size;
    if (target > pos) {

      if (__has_trivial_constructor(T)) {
        pos = target;
      } else {
        while (pos < target) {
          kj::ctor(*pos++);
        }
      }
    } else {

      if (__has_trivial_destructor(T)) {
        pos = target;
      } else {
        while (pos > target) {
          kj::dtor(*--pos);
        }
      }
    }
  }

  Array<T> finish() {






                                                                            ;
    Array<T> result(reinterpret_cast<T*>(ptr), pos - ptr, *disposer);
    ptr = nullptr;
    pos = nullptr;
    endPtr = nullptr;
    return result;
  }

  inline bool isFull() const {
    return pos == endPtr;
  }

private:
  T* ptr;
  RemoveConst<T>* pos;
  T* endPtr;
  const ArrayDisposer* disposer;

  inline void dispose() {


    T* ptrCopy = ptr;
    T* posCopy = pos;
    T* endCopy = endPtr;
    if (ptrCopy != nullptr) {
      ptr = nullptr;
      pos = nullptr;
      endPtr = nullptr;
      disposer->dispose(ptrCopy, posCopy - ptrCopy, endCopy - ptrCopy);
    }
  }
};

template <typename T>
inline ArrayBuilder<T> heapArrayBuilder(size_t size) {



  return ArrayBuilder<T>(_::HeapArrayDisposer::allocateUninitialized<RemoveConst<T>>(size),
                         size, _::HeapArrayDisposer::instance);
}




template <typename T, size_t fixedSize>
class FixedArray {


public:
  inline size_t size() const { return fixedSize; }
  inline T* begin() { return content; }
  inline T* end() { return content + fixedSize; }
  inline const T* begin() const { return content; }
  inline const T* end() const { return content + fixedSize; }

  inline operator ArrayPtr<T>() {
    return arrayPtr(content, fixedSize);
  }
  inline operator ArrayPtr<const T>() const {
    return arrayPtr(content, fixedSize);
  }

  inline T& operator[](size_t index) { return content[index]; }
  inline const T& operator[](size_t index) const { return content[index]; }

private:
  T content[fixedSize];
};

template <typename T, size_t fixedSize>
class CappedArray {





public:
  inline constexpr CappedArray(): currentSize(fixedSize) {}
  inline explicit constexpr CappedArray(size_t s): currentSize(s) {}

  inline size_t size() const { return currentSize; }
  inline void setSize(size_t s) { ; currentSize = s; }
  inline T* begin() { return content; }
  inline T* end() { return content + currentSize; }
  inline const T* begin() const { return content; }
  inline const T* end() const { return content + currentSize; }

  inline operator ArrayPtr<T>() {
    return arrayPtr(content, currentSize);
  }
  inline operator ArrayPtr<const T>() const {
    return arrayPtr(content, currentSize);
  }

  inline T& operator[](size_t index) { return content[index]; }
  inline const T& operator[](size_t index) const { return content[index]; }

private:
  size_t currentSize;
  T content[fixedSize];
};




#define KJ_MAP(elementName,array) ::kj::_::Mapper<KJ_DECLTYPE_REF(array)>(array) * [&](typename ::kj::_::Mapper<KJ_DECLTYPE_REF(array)>::Element elementName)
# 554 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/array.h" 3
namespace _ {

template <typename T>
struct Mapper {
  T array;
  Mapper(T&& array): array(kj::fwd<T>(array)) {}
  template <typename Func>
  auto operator*(Func&& func) -> Array<decltype(func(*array.begin()))> {
    auto builder = heapArrayBuilder<decltype(func(*array.begin()))>(array.size());
    for (auto iter = array.begin(); iter != array.end(); ++iter) {
      builder.add(func(*iter));
    }
    return builder.finish();
  }
  typedef decltype(*kj::instance<T>().begin()) Element;
};

template <typename T, size_t s>
struct Mapper<T(&)[s]> {
  T* array;
  Mapper(T* array): array(array) {}
  template <typename Func>
  auto operator*(Func&& func) -> Array<decltype(func(*array))> {
    auto builder = heapArrayBuilder<decltype(func(*array))>(s);
    for (size_t i = 0; i < s; i++) {
      builder.add(func(array[i]));
    }
    return builder.finish();
  }
  typedef decltype(*array)& Element;
};

}




template <typename T>
struct ArrayDisposer::Dispose_<T, true> {
  static void dispose(T* firstElement, size_t elementCount, size_t capacity,
                      const ArrayDisposer& disposer) {
    disposer.disposeImpl(const_cast<RemoveConst<T>*>(firstElement),
                         sizeof(T), elementCount, capacity, nullptr);
  }
};
template <typename T>
struct ArrayDisposer::Dispose_<T, false> {
  static void destruct(void* ptr) {
    kj::dtor(*reinterpret_cast<T*>(ptr));
  }

  static void dispose(T* firstElement, size_t elementCount, size_t capacity,
                      const ArrayDisposer& disposer) {
    disposer.disposeImpl(firstElement, sizeof(T), elementCount, capacity, &destruct);
  }
};

template <typename T>
void ArrayDisposer::dispose(T* firstElement, size_t elementCount, size_t capacity) const {
  Dispose_<T>::dispose(firstElement, elementCount, capacity, *this);
}

namespace _ {

template <typename T>
struct HeapArrayDisposer::Allocate_<T, true, true> {
  static T* allocate(size_t elementCount, size_t capacity) {
    return reinterpret_cast<T*>(allocateImpl(
        sizeof(T), elementCount, capacity, nullptr, nullptr));
  }
};
template <typename T>
struct HeapArrayDisposer::Allocate_<T, false, true> {
  static void construct(void* ptr) {
    kj::ctor(*reinterpret_cast<T*>(ptr));
  }
  static T* allocate(size_t elementCount, size_t capacity) {
    return reinterpret_cast<T*>(allocateImpl(
        sizeof(T), elementCount, capacity, &construct, nullptr));
  }
};
template <typename T>
struct HeapArrayDisposer::Allocate_<T, false, false> {
  static void construct(void* ptr) {
    kj::ctor(*reinterpret_cast<T*>(ptr));
  }
  static void destruct(void* ptr) {
    kj::dtor(*reinterpret_cast<T*>(ptr));
  }
  static T* allocate(size_t elementCount, size_t capacity) {
    return reinterpret_cast<T*>(allocateImpl(
        sizeof(T), elementCount, capacity, &construct, &destruct));
  }
};

template <typename T>
T* HeapArrayDisposer::allocate(size_t count) {
  return Allocate_<T>::allocate(count, count);
}

template <typename T>
T* HeapArrayDisposer::allocateUninitialized(size_t count) {
  return Allocate_<T, true, true>::allocate(0, count);
}

template <typename Element, typename Iterator, bool move, bool = canMemcpy<Element>()>
struct CopyConstructArray_;

template <typename T, bool move>
struct CopyConstructArray_<T, T*, move, true> {
  static inline T* apply(T* __restrict__ pos, T* start, T* end) {
    memcpy(pos, start, reinterpret_cast<byte*>(end) - reinterpret_cast<byte*>(start));
    return pos + (end - start);
  }
};

template <typename T>
struct CopyConstructArray_<T, const T*, false, true> {
  static inline T* apply(T* __restrict__ pos, const T* start, const T* end) {
    memcpy(pos, start, reinterpret_cast<const byte*>(end) - reinterpret_cast<const byte*>(start));
    return pos + (end - start);
  }
};

template <typename T, typename Iterator, bool move>
struct CopyConstructArray_<T, Iterator, move, true> {
  static inline T* apply(T* __restrict__ pos, Iterator start, Iterator end) {



    while (start != end) {
      *pos++ = *start++;
    }
    return pos;
  }
};

template <typename T, typename Iterator>
struct CopyConstructArray_<T, Iterator, false, false> {
  struct ExceptionGuard {
    T* start;
    T* pos;
    inline explicit ExceptionGuard(T* pos): start(pos), pos(pos) {}
    ~ExceptionGuard() noexcept(false) {
      while (pos > start) {
        dtor(*--pos);
      }
    }
  };

  static T* apply(T* __restrict__ pos, Iterator start, Iterator end) {

    if (false) implicitCast<T>(*start);

    if (noexcept(T(*start))) {
      while (start != end) {
        ctor(*pos++, *start++);
      }
      return pos;
    } else {

      ExceptionGuard guard(pos);
      while (start != end) {
        ctor(*guard.pos, *start++);
        ++guard.pos;
      }
      guard.start = guard.pos;
      return guard.pos;
    }
  }
};

template <typename T, typename Iterator>
struct CopyConstructArray_<T, Iterator, true, false> {


  struct ExceptionGuard {
    T* start;
    T* pos;
    inline explicit ExceptionGuard(T* pos): start(pos), pos(pos) {}
    ~ExceptionGuard() noexcept(false) {
      while (pos > start) {
        dtor(*--pos);
      }
    }
  };

  static T* apply(T* __restrict__ pos, Iterator start, Iterator end) {

    if (false) implicitCast<T>(kj::mv(*start));

    if (noexcept(T(kj::mv(*start)))) {
      while (start != end) {
        ctor(*pos++, kj::mv(*start++));
      }
      return pos;
    } else {

      ExceptionGuard guard(pos);
      while (start != end) {
        ctor(*guard.pos, kj::mv(*start++));
        ++guard.pos;
      }
      guard.start = guard.pos;
      return guard.pos;
    }
  }
};

}

template <typename T>
template <typename Iterator, bool move>
void ArrayBuilder<T>::addAll(Iterator start, Iterator end) {
  pos = _::CopyConstructArray_<RemoveConst<T>, Decay<Iterator>, move>::apply(pos, start, end);
}

template <typename T>
Array<T> heapArray(const T* content, size_t size) {
  ArrayBuilder<T> builder = heapArrayBuilder<T>(size);
  builder.addAll(content, content + size);
  return builder.finish();
}

template <typename T>
Array<T> heapArray(T* content, size_t size) {
  ArrayBuilder<T> builder = heapArrayBuilder<T>(size);
  builder.addAll(content, content + size);
  return builder.finish();
}

template <typename T>
Array<T> heapArray(ArrayPtr<T> content) {
  ArrayBuilder<T> builder = heapArrayBuilder<T>(content.size());
  builder.addAll(content);
  return builder.finish();
}

template <typename T>
Array<T> heapArray(ArrayPtr<const T> content) {
  ArrayBuilder<T> builder = heapArrayBuilder<T>(content.size());
  builder.addAll(content);
  return builder.finish();
}

template <typename T, typename Iterator> Array<T>
heapArray(Iterator begin, Iterator end) {
  ArrayBuilder<T> builder = heapArrayBuilder<T>(end - begin);
  builder.addAll(begin, end);
  return builder.finish();
}

template <typename T>
inline Array<T> heapArray(std::initializer_list<T> init) {
  return heapArray<T>(init.begin(), init.end());
}

}
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 2 3


namespace kj {

class StringPtr;
class String;

class StringTree;




#define KJ_COMPILER_SUPPORTS_STL_STRING_INTEROP 1
# 53 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3
class StringPtr {
public:
  inline StringPtr(): content("", 1) {}
  inline StringPtr(decltype(nullptr)): content("", 1) {}
  inline StringPtr(const char* value): content(value, strlen(value) + 1) {}
  inline StringPtr(const char* value, size_t size): content(value, size + 1) {
                                                                         ;
  }
  inline StringPtr(const char* begin, const char* end): StringPtr(begin, end - begin) {}
  inline StringPtr(const String& value);


  template <typename T, typename = decltype(instance<T>().c_str())>
  inline StringPtr(const T& t): StringPtr(t.c_str()) {}




  template <typename T, typename = decltype(instance<T>().c_str())>
  inline operator T() const { return cStr(); }





  inline operator ArrayPtr<const char>() const;
  inline ArrayPtr<const char> asArray() const;
  inline ArrayPtr<const byte> asBytes() const { return asArray().asBytes(); }


  inline const char* cStr() const { return content.begin(); }


  inline size_t size() const { return content.size() - 1; }


  inline char operator[](size_t index) const { return content[index]; }

  inline const char* begin() const { return content.begin(); }
  inline const char* end() const { return content.end() - 1; }

  inline bool operator==(decltype(nullptr)) const { return content.size() <= 1; }
  inline bool operator!=(decltype(nullptr)) const { return content.size() > 1; }

  inline bool operator==(const StringPtr& other) const;
  inline bool operator!=(const StringPtr& other) const { return !(*this == other); }
  inline bool operator< (const StringPtr& other) const;
  inline bool operator> (const StringPtr& other) const { return other < *this; }
  inline bool operator<=(const StringPtr& other) const { return !(other < *this); }
  inline bool operator>=(const StringPtr& other) const { return !(*this < other); }

  inline StringPtr slice(size_t start) const;
  inline ArrayPtr<const char> slice(size_t start, size_t end) const;



  inline bool startsWith(const StringPtr& other) const;
  inline bool endsWith(const StringPtr& other) const;

  inline Maybe<size_t> findFirst(char c) const;
  inline Maybe<size_t> findLast(char c) const;

  template <typename T>
  T parseAs() const;






private:
  inline StringPtr(ArrayPtr<const char> content): content(content) {}

  ArrayPtr<const char> content;
};

inline bool operator==(const char* a, const StringPtr& b) { return b == a; }
inline bool operator!=(const char* a, const StringPtr& b) { return b != a; }

template <> char StringPtr::parseAs<char>() const;
template <> signed char StringPtr::parseAs<signed char>() const;
template <> unsigned char StringPtr::parseAs<unsigned char>() const;
template <> short StringPtr::parseAs<short>() const;
template <> unsigned short StringPtr::parseAs<unsigned short>() const;
template <> int StringPtr::parseAs<int>() const;
template <> unsigned StringPtr::parseAs<unsigned>() const;
template <> long StringPtr::parseAs<long>() const;
template <> unsigned long StringPtr::parseAs<unsigned long>() const;
template <> long long StringPtr::parseAs<long long>() const;
template <> unsigned long long StringPtr::parseAs<unsigned long long>() const;
template <> float StringPtr::parseAs<float>() const;
template <> double StringPtr::parseAs<double>() const;
# 156 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3
class String {
public:
  String() = default;
  inline String(decltype(nullptr)): content(nullptr) {}
  inline String(char* value, size_t size, const ArrayDisposer& disposer);

  inline explicit String(Array<char> buffer);


  inline operator ArrayPtr<char>();
  inline operator ArrayPtr<const char>() const;
  inline ArrayPtr<char> asArray();
  inline ArrayPtr<const char> asArray() const;
  inline ArrayPtr<byte> asBytes() { return asArray().asBytes(); }
  inline ArrayPtr<const byte> asBytes() const { return asArray().asBytes(); }


  inline Array<char> releaseArray() { return kj::mv(content); }



  inline const char* cStr() const;

  inline size_t size() const;


  inline char operator[](size_t index) const;
  inline char& operator[](size_t index);

  inline char* begin();
  inline char* end();
  inline const char* begin() const;
  inline const char* end() const;

  inline bool operator==(decltype(nullptr)) const { return content.size() <= 1; }
  inline bool operator!=(decltype(nullptr)) const { return content.size() > 1; }

  inline bool operator==(const StringPtr& other) const { return StringPtr(*this) == other; }
  inline bool operator!=(const StringPtr& other) const { return StringPtr(*this) != other; }
  inline bool operator< (const StringPtr& other) const { return StringPtr(*this) < other; }
  inline bool operator> (const StringPtr& other) const { return StringPtr(*this) > other; }
  inline bool operator<=(const StringPtr& other) const { return StringPtr(*this) <= other; }
  inline bool operator>=(const StringPtr& other) const { return StringPtr(*this) >= other; }

  inline bool startsWith(const StringPtr& other) const { return StringPtr(*this).startsWith(other);}
  inline bool endsWith(const StringPtr& other) const { return StringPtr(*this).endsWith(other); }

  inline StringPtr slice(size_t start) const { return StringPtr(*this).slice(start); }
  inline ArrayPtr<const char> slice(size_t start, size_t end) const {
    return StringPtr(*this).slice(start, end);
  }

  inline Maybe<size_t> findFirst(char c) const { return StringPtr(*this).findFirst(c); }
  inline Maybe<size_t> findLast(char c) const { return StringPtr(*this).findLast(c); }

  template <typename T>
  T parseAs() const { return StringPtr(*this).parseAs<T>(); }


private:
  Array<char> content;
};

inline bool operator==(const char* a, const String& b) { return b == a; }
inline bool operator!=(const char* a, const String& b) { return b != a; }

String heapString(size_t size);



String heapString(const char* value);
String heapString(const char* value, size_t size);
String heapString(StringPtr value);
String heapString(const String& value);
String heapString(ArrayPtr<const char> value);






namespace _ {

inline size_t sum(std::initializer_list<size_t> nums) {
  size_t result = 0;
  for (auto num: nums) {
    result += num;
  }
  return result;
}

inline char* fill(char* ptr) { return ptr; }

template <typename... Rest>
char* fill(char* __restrict__ target, const StringTree& first, Rest&&... rest);




template <typename First, typename... Rest>
char* fill(char* __restrict__ target, const First& first, Rest&&... rest) {
  auto i = first.begin();
  auto end = first.end();
  while (i != end) {
    *target++ = *i++;
  }
  return fill(target, kj::fwd<Rest>(rest)...);
}

template <typename... Params>
String concat(Params&&... params) {



  String result = heapString(sum({params.size()...}));
  fill(result.begin(), kj::fwd<Params>(params)...);
  return result;
}

inline String concat(String&& arr) {
  return kj::mv(arr);
}

struct Stringifier {
# 292 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3
  inline ArrayPtr<const char> operator*(ArrayPtr<const char> s) const { return s; }
  inline ArrayPtr<const char> operator*(ArrayPtr<char> s) const { return s; }
  inline ArrayPtr<const char> operator*(const Array<const char>& s) const { return s; }
  inline ArrayPtr<const char> operator*(const Array<char>& s) const { return s; }
  template<size_t n>
  inline ArrayPtr<const char> operator*(const CappedArray<char, n>& s) const { return s; }
  template<size_t n>
  inline ArrayPtr<const char> operator*(const FixedArray<char, n>& s) const { return s; }
  inline ArrayPtr<const char> operator*(const char* s) const { return arrayPtr(s, strlen(s)); }
  inline ArrayPtr<const char> operator*(const String& s) const { return s.asArray(); }
  inline ArrayPtr<const char> operator*(const StringPtr& s) const { return s.asArray(); }

  inline Range<char> operator*(const Range<char>& r) const { return r; }
  inline Repeat<char> operator*(const Repeat<char>& r) const { return r; }

  inline FixedArray<char, 1> operator*(char c) const {
    FixedArray<char, 1> result;
    result[0] = c;
    return result;
  }

  StringPtr operator*(decltype(nullptr)) const;
  StringPtr operator*(bool b) const;

  CappedArray<char, 5> operator*(signed char i) const;
  CappedArray<char, 5> operator*(unsigned char i) const;
  CappedArray<char, sizeof(short) * 3 + 2> operator*(short i) const;
  CappedArray<char, sizeof(unsigned short) * 3 + 2> operator*(unsigned short i) const;
  CappedArray<char, sizeof(int) * 3 + 2> operator*(int i) const;
  CappedArray<char, sizeof(unsigned int) * 3 + 2> operator*(unsigned int i) const;
  CappedArray<char, sizeof(long) * 3 + 2> operator*(long i) const;
  CappedArray<char, sizeof(unsigned long) * 3 + 2> operator*(unsigned long i) const;
  CappedArray<char, sizeof(long long) * 3 + 2> operator*(long long i) const;
  CappedArray<char, sizeof(unsigned long long) * 3 + 2> operator*(unsigned long long i) const;
  CappedArray<char, 24> operator*(float f) const;
  CappedArray<char, 32> operator*(double f) const;
  CappedArray<char, sizeof(const void*) * 3 + 2> operator*(const void* s) const;

  template <typename T>
  String operator*(ArrayPtr<T> arr) const;
  template <typename T>
  String operator*(const Array<T>& arr) const;


  template <typename T, typename Result = decltype(instance<T>().toString())>
  inline Result operator*(T&& value) const { return kj::fwd<T>(value).toString(); }

};
static constexpr Stringifier STR = Stringifier();

}

template <typename T>
auto toCharSequence(T&& value) -> decltype(_::STR * kj::fwd<T>(value)) {
# 354 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3
  return _::STR * kj::fwd<T>(value);
}

CappedArray<char, sizeof(unsigned char) * 2 + 1> hex(unsigned char i);
CappedArray<char, sizeof(unsigned short) * 2 + 1> hex(unsigned short i);
CappedArray<char, sizeof(unsigned int) * 2 + 1> hex(unsigned int i);
CappedArray<char, sizeof(unsigned long) * 2 + 1> hex(unsigned long i);
CappedArray<char, sizeof(unsigned long long) * 2 + 1> hex(unsigned long long i);

template <typename... Params>
String str(Params&&... params) {






  return _::concat(toCharSequence(kj::fwd<Params>(params))...);
}

inline String str(String&& s) { return mv(s); }


template <typename T>
String strArray(T&& arr, const char* delim) {
  size_t delimLen = strlen(delim);
  size_t pieces_size = (kj::size(arr)); bool pieces_isOnStack = pieces_size <= (8); decltype(_::STR * arr[0]) pieces_stack[8]; ::kj::Array<decltype(_::STR * arr[0])> pieces_heap = pieces_isOnStack ? nullptr : kj::heapArray<decltype(_::STR * arr[0])>(pieces_size); ::kj::ArrayPtr<decltype(_::STR * arr[0])> pieces = pieces_isOnStack ? kj::arrayPtr(pieces_stack, pieces_size) : pieces_heap;
  size_t size = 0;
  for (size_t i = 0; i < kj::size(arr); i++) {
    if (i > 0) size += delimLen;
    pieces[i] = _::STR * arr[i];
    size += pieces[i].size();
  }

  String result = heapString(size);
  char* pos = result.begin();
  for (size_t i = 0; i < kj::size(arr); i++) {
    if (i > 0) {
      memcpy(pos, delim, delimLen);
      pos += delimLen;
    }
    pos = _::fill(pos, pieces[i]);
  }
  return result;
}

namespace _ {

template <typename T>
inline String Stringifier::operator*(ArrayPtr<T> arr) const {
  return strArray(arr, ", ");
}

template <typename T>
inline String Stringifier::operator*(const Array<T>& arr) const {
  return strArray(arr, ", ");
}

}

#define KJ_STRINGIFY(...) operator*(::kj::_::Stringifier, __VA_ARGS__)
# 428 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string.h" 3
inline StringPtr::StringPtr(const String& value): content(value.begin(), value.size() + 1) {}

inline StringPtr::operator ArrayPtr<const char>() const {
  return content.slice(0, content.size() - 1);
}

inline ArrayPtr<const char> StringPtr::asArray() const {
  return content.slice(0, content.size() - 1);
}

inline bool StringPtr::operator==(const StringPtr& other) const {
  return content.size() == other.content.size() &&
      memcmp(content.begin(), other.content.begin(), content.size() - 1) == 0;
}

inline bool StringPtr::operator<(const StringPtr& other) const {
  bool shorter = content.size() < other.content.size();
  int cmp = memcmp(content.begin(), other.content.begin(),
                   shorter ? content.size() : other.content.size());
  return cmp < 0 || (cmp == 0 && shorter);
}

inline StringPtr StringPtr::slice(size_t start) const {
  return StringPtr(content.slice(start, content.size()));
}
inline ArrayPtr<const char> StringPtr::slice(size_t start, size_t end) const {
  return content.slice(start, end);
}

inline bool StringPtr::startsWith(const StringPtr& other) const {
  return other.content.size() <= content.size() &&
      memcmp(content.begin(), other.content.begin(), other.size()) == 0;
}
inline bool StringPtr::endsWith(const StringPtr& other) const {
  return other.content.size() <= content.size() &&
      memcmp(end() - other.size(), other.content.begin(), other.size()) == 0;
}

inline Maybe<size_t> StringPtr::findFirst(char c) const {
  const char* pos = reinterpret_cast<const char*>(memchr(content.begin(), c, size()));
  if (pos == nullptr) {
    return nullptr;
  } else {
    return pos - content.begin();
  }
}

inline Maybe<size_t> StringPtr::findLast(char c) const {
  for (size_t i = size(); i > 0; --i) {
    if (content[i-1] == c) {
      return i-1;
    }
  }
  return nullptr;
}

inline String::operator ArrayPtr<char>() {
  return content == nullptr ? ArrayPtr<char>(nullptr) : content.slice(0, content.size() - 1);
}
inline String::operator ArrayPtr<const char>() const {
  return content == nullptr ? ArrayPtr<const char>(nullptr) : content.slice(0, content.size() - 1);
}

inline ArrayPtr<char> String::asArray() {
  return content == nullptr ? ArrayPtr<char>(nullptr) : content.slice(0, content.size() - 1);
}
inline ArrayPtr<const char> String::asArray() const {
  return content == nullptr ? ArrayPtr<const char>(nullptr) : content.slice(0, content.size() - 1);
}

inline const char* String::cStr() const { return content == nullptr ? "" : content.begin(); }

inline size_t String::size() const { return content == nullptr ? 0 : content.size() - 1; }

inline char String::operator[](size_t index) const { return content[index]; }
inline char& String::operator[](size_t index) { return content[index]; }

inline char* String::begin() { return content == nullptr ? nullptr : content.begin(); }
inline char* String::end() { return content == nullptr ? nullptr : content.end() - 1; }
inline const char* String::begin() const { return content == nullptr ? nullptr : content.begin(); }
inline const char* String::end() const { return content == nullptr ? nullptr : content.end() - 1; }

inline String::String(char* value, size_t size, const ArrayDisposer& disposer)
    : content(value, size + 1, disposer) {
                                                                    ;
}

inline String::String(Array<char> buffer): content(kj::mv(buffer)) {
                                                                                             ;
}

inline String heapString(const char* value) {
  return heapString(value, strlen(value));
}
inline String heapString(StringPtr value) {
  return heapString(value.begin(), value.size());
}
inline String heapString(const String& value) {
  return heapString(value.begin(), value.size());
}
inline String heapString(ArrayPtr<const char> value) {
  return heapString(value.begin(), value.size());
}

}
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/memory.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/memory.h" 3
#define KJ_MEMORY_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/memory.h" 3




namespace kj {




class Disposer {







protected:



  virtual void disposeImpl(void* pointer) const = 0;





public:

  template <typename T>
  void dispose(T* object) const;
# 66 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/memory.h" 3
private:
  template <typename T, bool polymorphic = __is_polymorphic(T)>
  struct Dispose_;
};

template <typename T>
class DestructorOnlyDisposer: public Disposer {


public:
  static const DestructorOnlyDisposer instance;

  void disposeImpl(void* pointer) const override {
    reinterpret_cast<T*>(pointer)->~T();
  }
};

template <typename T>
const DestructorOnlyDisposer<T> DestructorOnlyDisposer<T>::instance = DestructorOnlyDisposer<T>();

class NullDisposer: public Disposer {


public:
  static const NullDisposer instance;

  void disposeImpl(void* pointer) const override {}
};




template <typename T>
class Own {
# 114 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/memory.h" 3
public:
  Own(const Own&) = delete; Own& operator=(const Own&) = delete;
  inline Own(): disposer(nullptr), ptr(nullptr) {}
  inline Own(Own&& other) noexcept
      : disposer(other.disposer), ptr(other.ptr) { other.ptr = nullptr; }
  inline Own(Own<RemoveConstOrDisable<T>>&& other) noexcept
      : disposer(other.disposer), ptr(other.ptr) { other.ptr = nullptr; }
  template <typename U, typename = EnableIf<canConvert<U*, T*>()>>
  inline Own(Own<U>&& other) noexcept
      : disposer(other.disposer), ptr(other.ptr) {
    static_assert(__is_polymorphic(T),
        "Casting owned pointers requires that the target type is polymorphic.");
    other.ptr = nullptr;
  }
  inline Own(T* ptr, const Disposer& disposer) noexcept: disposer(&disposer), ptr(ptr) {}

  ~Own() noexcept(false) { dispose(); }

  inline Own& operator=(Own&& other) {




    const Disposer* disposerCopy = disposer;
    T* ptrCopy = ptr;
    disposer = other.disposer;
    ptr = other.ptr;
    other.ptr = nullptr;
    if (ptrCopy != nullptr) {
      disposerCopy->dispose(const_cast<RemoveConst<T>*>(ptrCopy));
    }
    return *this;
  }

  inline Own& operator=(decltype(nullptr)) {
    dispose();
    return *this;
  }

  template <typename U>
  Own<U> downcast() {




    Own<U> result;
    if (ptr != nullptr) {
      result.ptr = &kj::downcast<U>(*ptr);
      result.disposer = disposer;
      ptr = nullptr;
    }
    return result;
  }

#define NULLCHECK KJ_IREQUIRE(ptr != nullptr, "null Own<> dereference")
 inline T* operator->() { ; return ptr; }
  inline const T* operator->() const { ; return ptr; }
  inline T& operator*() { ; return *ptr; }
  inline const T& operator*() const { ; return *ptr; }
#undef NULLCHECK
 inline T* get() { return ptr; }
  inline const T* get() const { return ptr; }
  inline operator T*() { return ptr; }
  inline operator const T*() const { return ptr; }

private:
  const Disposer* disposer;
  T* ptr;

  inline explicit Own(decltype(nullptr)): disposer(nullptr), ptr(nullptr) {}

  inline bool operator==(decltype(nullptr)) { return ptr == nullptr; }
  inline bool operator!=(decltype(nullptr)) { return ptr != nullptr; }


  inline void dispose() {


    T* ptrCopy = ptr;
    if (ptrCopy != nullptr) {
      ptr = nullptr;
      disposer->dispose(const_cast<RemoveConst<T>*>(ptrCopy));
    }
  }

  template <typename U>
  friend class Own;
  friend class Maybe<Own<T>>;
};

namespace _ {

template <typename T>
class OwnOwn {
public:
  inline OwnOwn(Own<T>&& value) noexcept: value(kj::mv(value)) {}

  inline Own<T>& operator*() & { return value; }
  inline const Own<T>& operator*() const & { return value; }
  inline Own<T>&& operator*() && { return kj::mv(value); }
  inline const Own<T>&& operator*() const && { return kj::mv(value); }
  inline Own<T>* operator->() { return &value; }
  inline const Own<T>* operator->() const { return &value; }
  inline operator Own<T>*() { return value ? &value : nullptr; }
  inline operator const Own<T>*() const { return value ? &value : nullptr; }

private:
  Own<T> value;
};

template <typename T>
OwnOwn<T> readMaybe(Maybe<Own<T>>&& maybe) { return OwnOwn<T>(kj::mv(maybe.ptr)); }
template <typename T>
Own<T>* readMaybe(Maybe<Own<T>>& maybe) { return maybe.ptr ? &maybe.ptr : nullptr; }
template <typename T>
const Own<T>* readMaybe(const Maybe<Own<T>>& maybe) { return maybe.ptr ? &maybe.ptr : nullptr; }

}

template <typename T>
class Maybe<Own<T>> {
public:
  inline Maybe(): ptr(nullptr) {}
  inline Maybe(Own<T>&& t) noexcept: ptr(kj::mv(t)) {}
  inline Maybe(Maybe&& other) noexcept: ptr(kj::mv(other.ptr)) {}

  template <typename U>
  inline Maybe(Maybe<Own<U>>&& other): ptr(mv(other.ptr)) {}
  template <typename U>
  inline Maybe(Own<U>&& other): ptr(mv(other)) {}

  inline Maybe(decltype(nullptr)) noexcept: ptr(nullptr) {}

  inline operator Maybe<T&>() { return ptr.get(); }
  inline operator Maybe<const T&>() const { return ptr.get(); }

  inline Maybe& operator=(Maybe&& other) { ptr = kj::mv(other.ptr); return *this; }

  inline bool operator==(decltype(nullptr)) const { return ptr == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return ptr != nullptr; }

  Own<T>& orDefault(Own<T>& defaultValue) {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return ptr;
    }
  }
  const Own<T>& orDefault(const Own<T>& defaultValue) const {
    if (ptr == nullptr) {
      return defaultValue;
    } else {
      return ptr;
    }
  }

  template <typename Func>
  auto map(Func&& f) & -> Maybe<decltype(f(instance<Own<T>&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(ptr);
    }
  }

  template <typename Func>
  auto map(Func&& f) const & -> Maybe<decltype(f(instance<const Own<T>&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(ptr);
    }
  }

  template <typename Func>
  auto map(Func&& f) && -> Maybe<decltype(f(instance<Own<T>&&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(kj::mv(ptr));
    }
  }

  template <typename Func>
  auto map(Func&& f) const && -> Maybe<decltype(f(instance<const Own<T>&&>()))> {
    if (ptr == nullptr) {
      return nullptr;
    } else {
      return f(kj::mv(ptr));
    }
  }

private:
  Own<T> ptr;

  template <typename U>
  friend class Maybe;
  template <typename U>
  friend _::OwnOwn<U> _::readMaybe(Maybe<Own<U>>&& maybe);
  template <typename U>
  friend Own<U>* _::readMaybe(Maybe<Own<U>>& maybe);
  template <typename U>
  friend const Own<U>* _::readMaybe(const Maybe<Own<U>>& maybe);
};

namespace _ {

template <typename T>
class HeapDisposer final: public Disposer {
public:
  virtual void disposeImpl(void* pointer) const override { delete reinterpret_cast<T*>(pointer); }

  static const HeapDisposer instance;
};

template <typename T>
const HeapDisposer<T> HeapDisposer<T>::instance = HeapDisposer<T>();

}

template <typename T, typename... Params>
Own<T> heap(Params&&... params) {





  return Own<T>(new T(kj::fwd<Params>(params)...), _::HeapDisposer<T>::instance);
}

template <typename T>
Own<Decay<T>> heap(T&& orig) {





  typedef Decay<T> T2;
  return Own<T2>(new T2(kj::fwd<T>(orig)), _::HeapDisposer<T2>::instance);
}




template <typename T>
class SpaceFor {




public:
  inline SpaceFor() {}
  inline ~SpaceFor() {}

  template <typename... Params>
  Own<T> construct(Params&&... params) {
    ctor(value, kj::fwd<Params>(params)...);
    return Own<T>(&value, DestructorOnlyDisposer<T>::instance);
  }

private:
  union {
    T value;
  };
};




template <typename T>
struct Disposer::Dispose_<T, true> {
  static void dispose(T* object, const Disposer& disposer) {



    disposer.disposeImpl(dynamic_cast<void*>(object));
  }
};
template <typename T>
struct Disposer::Dispose_<T, false> {
  static void dispose(T* object, const Disposer& disposer) {
    disposer.disposeImpl(static_cast<void*>(object));
  }
};

template <typename T>
void Disposer::dispose(T* object) const {
  Dispose_<T>::dispose(object, *this);
}

}
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 2 3





namespace capnp {

#define CAPNP_VERSION_MAJOR 0
#define CAPNP_VERSION_MINOR 6
#define CAPNP_VERSION_MICRO 1

#define CAPNP_VERSION (CAPNP_VERSION_MAJOR * 1000000 + CAPNP_VERSION_MINOR * 1000 + CAPNP_VERSION_MICRO)



#define CAPNP_LITE 0


typedef unsigned int uint;

struct Void {



  inline constexpr bool operator==(Void other) const { return true; }
  inline constexpr bool operator!=(Void other) const { return false; }
};

static constexpr Void VOID = Void();


inline kj::StringPtr operator*(::kj::_::Stringifier, Void) { return "void"; }

struct Text;
struct Data;

enum class Kind: uint8_t {
  PRIMITIVE,
  BLOB,
  ENUM,
  STRUCT,
  UNION,
  INTERFACE,
  LIST,

  OTHER


};

enum class Style: uint8_t {
  PRIMITIVE,
  POINTER,
  STRUCT,
  CAPABILITY
};

enum class ElementSize: uint8_t {


  VOID = 0,
  BIT = 1,
  BYTE = 2,
  TWO_BYTES = 3,
  FOUR_BYTES = 4,
  EIGHT_BYTES = 5,

  POINTER = 6,

  INLINE_COMPOSITE = 7
};

enum class PointerType {


  NULL_,


  STRUCT,
  LIST,
  CAPABILITY
};

namespace schemas {

template <typename T>
struct EnumInfo;

}

namespace _ {

template <typename T, typename = void> struct Kind_;

template <> struct Kind_<Void> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<bool> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<int8_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<int16_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<int32_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<int64_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<uint8_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<uint16_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<uint32_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<uint64_t> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<float> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<double> { static constexpr Kind kind = Kind::PRIMITIVE; };
template <> struct Kind_<Text> { static constexpr Kind kind = Kind::BLOB; };
template <> struct Kind_<Data> { static constexpr Kind kind = Kind::BLOB; };

template <typename T> struct Kind_<T, kj::VoidSfinae<typename T::_capnpPrivate::IsStruct>> {
  static constexpr Kind kind = Kind::STRUCT;
};
template <typename T> struct Kind_<T, kj::VoidSfinae<typename T::_capnpPrivate::IsInterface>> {
  static constexpr Kind kind = Kind::INTERFACE;
};
template <typename T> struct Kind_<T, kj::VoidSfinae<typename schemas::EnumInfo<T>::IsEnum>> {
  static constexpr Kind kind = Kind::ENUM;
};

}

template <typename T, Kind k = _::Kind_<T>::kind>
inline constexpr Kind kind() {


  return k;
}
# 171 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
#define CAPNP_KIND(T) ::capnp::kind<T>()






template <typename T, Kind k = kind<T>()>
inline constexpr Style style() {
  return k == Kind::PRIMITIVE || k == Kind::ENUM ? Style::PRIMITIVE
       : k == Kind::STRUCT ? Style::STRUCT
       : k == Kind::INTERFACE ? Style::CAPABILITY : Style::POINTER;
}



template <typename T, Kind k = ::capnp::kind<T>()>
struct List;
# 201 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
template <typename T> struct ListElementType_;
template <typename T> struct ListElementType_<List<T>> { typedef T Type; };
template <typename T> using ListElementType = typename ListElementType_<T>::Type;

namespace _ {
template <typename T, Kind k> struct Kind_<List<T, k>> {
  static constexpr Kind kind = Kind::LIST;
};
}

template <typename T, Kind k = ::capnp::kind<T>()> struct ReaderFor_ { typedef typename T::Reader Type; };
template <typename T> struct ReaderFor_<T, Kind::PRIMITIVE> { typedef T Type; };
template <typename T> struct ReaderFor_<T, Kind::ENUM> { typedef T Type; };
template <typename T> struct ReaderFor_<T, Kind::INTERFACE> { typedef typename T::Client Type; };
template <typename T> using ReaderFor = typename ReaderFor_<T>::Type;


template <typename T, Kind k = ::capnp::kind<T>()> struct BuilderFor_ { typedef typename T::Builder Type; };
template <typename T> struct BuilderFor_<T, Kind::PRIMITIVE> { typedef T Type; };
template <typename T> struct BuilderFor_<T, Kind::ENUM> { typedef T Type; };
template <typename T> struct BuilderFor_<T, Kind::INTERFACE> { typedef typename T::Client Type; };
template <typename T> using BuilderFor = typename BuilderFor_<T>::Type;


template <typename T, Kind k = ::capnp::kind<T>()> struct PipelineFor_ { typedef typename T::Pipeline Type;};
template <typename T> struct PipelineFor_<T, Kind::INTERFACE> { typedef typename T::Client Type; };
template <typename T> using PipelineFor = typename PipelineFor_<T>::Type;

template <typename T, Kind k = ::capnp::kind<T>()> struct TypeIfEnum_;
template <typename T> struct TypeIfEnum_<T, Kind::ENUM> { typedef T Type; };

template <typename T>
using TypeIfEnum = typename TypeIfEnum_<kj::Decay<T>>::Type;

template <typename T>
using FromReader = typename kj::Decay<T>::Reads;


template <typename T>
using FromBuilder = typename kj::Decay<T>::Builds;


template <typename T>
using FromPipeline = typename kj::Decay<T>::Pipelines;


template <typename T>
using FromClient = typename kj::Decay<T>::Calls;


template <typename T>
using FromServer = typename kj::Decay<T>::Serves;


template <typename T, typename = void>
struct FromAny_;

template <typename T>
struct FromAny_<T, kj::VoidSfinae<FromReader<T>>> {
  using Type = FromReader<T>;
};

template <typename T>
struct FromAny_<T, kj::VoidSfinae<FromBuilder<T>>> {
  using Type = FromBuilder<T>;
};

template <typename T>
struct FromAny_<T, kj::VoidSfinae<FromPipeline<T>>> {
  using Type = FromPipeline<T>;
};



template <typename T>
struct FromAny_<kj::Own<T>, kj::VoidSfinae<FromServer<T>>> {
  using Type = FromServer<T>;
};

template <typename T>
struct FromAny_<T,
    kj::EnableIf<_::Kind_<T>::kind == Kind::PRIMITIVE || _::Kind_<T>::kind == Kind::ENUM>> {



  using Type = kj::Decay<T>;
};

template <typename T>
using FromAny = typename FromAny_<T>::Type;
# 300 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
namespace _ {

template <typename T, Kind k = ::capnp::kind<T>()>
struct PointerHelpers;
# 316 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
}

struct MessageSize {

  uint64_t wordCount;
  uint capCount;
};




using kj::byte;

class word { uint64_t content __attribute__((unused)); word(const word&) = delete; word& operator=(const word&) = delete; public: word() = default; };
# 340 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
static_assert(sizeof(byte) == 1, "uint8_t is not one byte?");
static_assert(sizeof(word) == 8, "uint64_t is not 8 bytes?");
# 541 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/common.h" 3
template <uint width, typename T = uint>
using BitCountN = T;
template <uint width, typename T = uint>
using ByteCountN = T;
template <uint width, typename T = uint>
using WordCountN = T;
template <uint width, typename T = uint>
using ElementCountN = T;
template <uint width, typename T = uint>
using WirePointerCountN = T;



typedef BitCountN<8, uint8_t> BitCount8;
typedef BitCountN<16, uint16_t> BitCount16;
typedef BitCountN<32, uint32_t> BitCount32;
typedef BitCountN<64, uint64_t> BitCount64;
typedef BitCountN<sizeof(uint) * 8, uint> BitCount;

typedef ByteCountN<8, uint8_t> ByteCount8;
typedef ByteCountN<16, uint16_t> ByteCount16;
typedef ByteCountN<32, uint32_t> ByteCount32;
typedef ByteCountN<64, uint64_t> ByteCount64;
typedef ByteCountN<sizeof(uint) * 8, uint> ByteCount;

typedef WordCountN<8, uint8_t> WordCount8;
typedef WordCountN<16, uint16_t> WordCount16;
typedef WordCountN<32, uint32_t> WordCount32;
typedef WordCountN<64, uint64_t> WordCount64;
typedef WordCountN<sizeof(uint) * 8, uint> WordCount;

typedef ElementCountN<8, uint8_t> ElementCount8;
typedef ElementCountN<16, uint16_t> ElementCount16;
typedef ElementCountN<32, uint32_t> ElementCount32;
typedef ElementCountN<64, uint64_t> ElementCount64;
typedef ElementCountN<sizeof(uint) * 8, uint> ElementCount;

typedef WirePointerCountN<8, uint8_t> WirePointerCount8;
typedef WirePointerCountN<16, uint16_t> WirePointerCount16;
typedef WirePointerCountN<32, uint32_t> WirePointerCount32;
typedef WirePointerCountN<64, uint64_t> WirePointerCount64;
typedef WirePointerCountN<sizeof(uint) * 8, uint> WirePointerCount;

template <uint width>
using BitsPerElementN = decltype(BitCountN<width>() / ElementCountN<width>());
template <uint width>
using BytesPerElementN = decltype(ByteCountN<width>() / ElementCountN<width>());
template <uint width>
using WordsPerElementN = decltype(WordCountN<width>() / ElementCountN<width>());
template <uint width>
using PointersPerElementN = decltype(WirePointerCountN<width>() / ElementCountN<width>());

using kj::ThrowOverflow;


template <uint i> inline constexpr uint bounded() { return i; }
template <typename T> inline constexpr T bounded(T i) { return i; }
template <typename T> inline constexpr T unbound(T i) { return i; }

template <typename T, typename U> inline constexpr T unboundAs(U i) { return i; }

template <uint64_t requestedMax, typename T> inline constexpr uint unboundMax(T i) { return i; }
template <uint bits, typename T> inline constexpr uint unboundMaxBits(T i) { return i; }

template <uint newMax, typename T, typename ErrorFunc>
inline T assertMax(T value, ErrorFunc&& func) {
  if (__builtin_expect(value > newMax, false)) func();
  return value;
}

template <typename T, typename ErrorFunc>
inline T assertMax(uint newMax, T value, ErrorFunc&& func) {
  if (__builtin_expect(value > newMax, false)) func();
  return value;
}

template <uint bits, typename T, typename ErrorFunc = ThrowOverflow>
inline T assertMaxBits(T value, ErrorFunc&& func = ErrorFunc()) {
  if (__builtin_expect(value > kj::maxValueForBits<bits>(), false)) func();
  return value;
}

template <typename T, typename ErrorFunc = ThrowOverflow>
inline T assertMaxBits(uint bits, T value, ErrorFunc&& func = ErrorFunc()) {
  if (__builtin_expect(value > (1ull << bits) - 1, false)) func();
  return value;
}

template <typename T, typename U> inline constexpr T upgradeBound(U i) { return i; }

template <uint bits, typename T> inline constexpr T assumeBits(T i) { return i; }
template <uint64_t max, typename T> inline constexpr T assumeMax(T i) { return i; }

template <typename T, typename U, typename ErrorFunc = ThrowOverflow>
inline auto subtractChecked(T a, U b, ErrorFunc&& errorFunc = ErrorFunc())
    -> decltype(a - b) {
  if (b > a) errorFunc();
  return a - b;
}

template <typename T, typename U>
inline auto trySubtract(T a, U b) -> kj::Maybe<decltype(a - b)> {
  if (b > a) {
    return nullptr;
  } else {
    return a - b;
  }
}

constexpr uint BITS = 1;
constexpr uint BYTES = 1;
constexpr uint WORDS = 1;
constexpr uint ELEMENTS = 1;
constexpr uint POINTERS = 1;

constexpr uint ZERO = 0;
constexpr uint ONE = 1;


constexpr uint BITS_PER_BYTE __attribute__((unused)) = 8;
constexpr uint BITS_PER_WORD __attribute__((unused)) = 64;
constexpr uint BYTES_PER_WORD __attribute__((unused)) = 8;

constexpr uint BITS_PER_POINTER __attribute__((unused)) = 64;
constexpr uint BYTES_PER_POINTER __attribute__((unused)) = 8;
constexpr uint WORDS_PER_POINTER __attribute__((unused)) = 1;


constexpr uint POINTER_SIZE_IN_WORDS = ONE * POINTERS * WORDS_PER_POINTER;

constexpr uint SEGMENT_WORD_COUNT_BITS = 29;
constexpr uint LIST_ELEMENT_COUNT_BITS = 29;
constexpr uint STRUCT_DATA_WORD_COUNT_BITS = 16;
constexpr uint STRUCT_POINTER_COUNT_BITS = 16;
constexpr uint BLOB_SIZE_BITS = 29;

typedef WordCountN<SEGMENT_WORD_COUNT_BITS> SegmentWordCount;
typedef ElementCountN<LIST_ELEMENT_COUNT_BITS> ListElementCount;
typedef WordCountN<STRUCT_DATA_WORD_COUNT_BITS, uint16_t> StructDataWordCount;
typedef WirePointerCountN<STRUCT_POINTER_COUNT_BITS, uint16_t> StructPointerCount;
typedef ByteCountN<BLOB_SIZE_BITS> BlobSize;


constexpr auto MAX_SEGMENT_WORDS = kj::maxValueForBits<SEGMENT_WORD_COUNT_BITS>();
constexpr auto MAX_LIST_ELEMENTS = kj::maxValueForBits<LIST_ELEMENT_COUNT_BITS>();
constexpr auto MAX_STUCT_DATA_WORDS = kj::maxValueForBits<STRUCT_DATA_WORD_COUNT_BITS>();
constexpr auto MAX_STRUCT_POINTER_COUNT = kj::maxValueForBits<STRUCT_POINTER_COUNT_BITS>();

typedef uint StructDataBitCount;
typedef uint StructDataOffset;
typedef uint StructPointerOffset;

inline StructDataOffset assumeDataOffset(uint32_t offset) { return offset; }
inline StructPointerOffset assumePointerOffset(uint32_t offset) { return offset; }

constexpr uint MAX_TEXT_SIZE = kj::maxValueForBits<BLOB_SIZE_BITS>() - 1;
typedef uint TextSize;

template <typename T>
inline constexpr size_t bytesPerElement() { return sizeof(T); }

template <typename T>
inline constexpr size_t bitsPerElement() { return sizeof(T) * 8; }

template <typename T>
inline constexpr ptrdiff_t intervalLength(const T* a, const T* b, uint) {
  return b - a;
}

template <typename T, typename U>
inline constexpr kj::ArrayPtr<const U> arrayPtr(const U* ptr, T size) {
  return kj::arrayPtr(ptr, size);
}
template <typename T, typename U>
inline constexpr kj::ArrayPtr<U> arrayPtr(U* ptr, T size) {
  return kj::arrayPtr(ptr, size);
}



}
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/raw-schema.h" 2 3





namespace capnp {
namespace _ {

struct RawSchema;

struct RawBrandedSchema {






  const RawSchema* generic;


  struct Binding {
    uint8_t which;

    bool isImplicitParameter;


    uint16_t listDepth;

    uint16_t paramIndex;




    union {
      const RawBrandedSchema* schema;
      uint64_t scopeId;
    };

    Binding() = default;
    inline constexpr Binding(uint8_t which, uint16_t listDepth, const RawBrandedSchema* schema)
        : which(which), isImplicitParameter(false), listDepth(listDepth), paramIndex(0),
          schema(schema) {}
    inline constexpr Binding(uint8_t which, uint16_t listDepth,
                             uint64_t scopeId, uint16_t paramIndex)
        : which(which), isImplicitParameter(false), listDepth(listDepth), paramIndex(paramIndex),
          scopeId(scopeId) {}
    inline constexpr Binding(uint8_t which, uint16_t listDepth, uint16_t implicitParamIndex)
        : which(which), isImplicitParameter(true), listDepth(listDepth),
          paramIndex(implicitParamIndex), scopeId(0) {}
  };

  struct Scope {
    uint64_t typeId;


    const Binding* bindings;
    uint bindingCount;


    bool isUnbound;

  };

  const Scope* scopes;


  struct Dependency {
    uint location;
    const RawBrandedSchema* schema;
  };

  const Dependency* dependencies;



  uint32_t scopeCount;
  uint32_t dependencyCount;

  enum class DepKind {


    INVALID,


    FIELD,


    METHOD_PARAMS,


    METHOD_RESULTS,


    SUPERCLASS,



    CONST_TYPE

  };

  static inline uint makeDepLocation(DepKind kind, uint index) {



    return (static_cast<uint>(kind) << 24) | index;
  }

  class Initializer {
  public:
    virtual void init(const RawBrandedSchema* generic) const = 0;
  };

  const Initializer* lazyInitializer;


  inline void ensureInitialized() const {





    const Initializer* i = __atomic_load_n(&lazyInitializer, 2);






    if (i != nullptr) i->init(this);
  }

  inline bool isUnbound() const;


};

struct RawSchema {




  uint64_t id;

  const word* encodedNode;


  uint32_t encodedSize;


  const RawSchema* const* dependencies;






  const uint16_t* membersByName;



  uint32_t dependencyCount;
  uint32_t memberCount;


  const uint16_t* membersByDiscriminant;



  const RawSchema* canCastTo;




  class Initializer {
  public:
    virtual void init(const RawSchema* schema) const = 0;
  };

  const Initializer* lazyInitializer;


  inline void ensureInitialized() const {





    const Initializer* i = __atomic_load_n(&lazyInitializer, 2);






    if (i != nullptr) i->init(this);
  }

  RawBrandedSchema defaultBrand;



};

inline bool RawBrandedSchema::isUnbound() const {

  return scopeCount == 0 && this != &generic->defaultBrand;
}

}
}
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3
#define CAPNP_LAYOUT_H_ 
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3





# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/blob.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/blob.h" 3
#define CAPNP_BLOB_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/blob.h" 3







namespace capnp {

struct Data {
  Data() = delete;
  class Reader;
  class Builder;
  class Pipeline {};
};

struct Text {
  Text() = delete;
  class Reader;
  class Builder;
  class Pipeline {};
};

class Data::Reader: public kj::ArrayPtr<const byte> {



public:
  typedef Data Reads;

  Reader() = default;
  inline Reader(decltype(nullptr)): ArrayPtr<const byte>(nullptr) {}
  inline Reader(const byte* value, size_t size): ArrayPtr<const byte>(value, size) {}
  inline Reader(const kj::Array<const byte>& value): ArrayPtr<const byte>(value) {}
  inline Reader(const ArrayPtr<const byte>& value): ArrayPtr<const byte>(value) {}
  inline Reader(const kj::Array<byte>& value): ArrayPtr<const byte>(value) {}
  inline Reader(const ArrayPtr<byte>& value): ArrayPtr<const byte>(value) {}
};

class Text::Reader: public kj::StringPtr {







public:
  typedef Text Reads;

  Reader() = default;
  inline Reader(decltype(nullptr)): StringPtr(nullptr) {}
  inline Reader(const char* value): StringPtr(value) {}
  inline Reader(const char* value, size_t size): StringPtr(value, size) {}
  inline Reader(const kj::String& value): StringPtr(value) {}
  inline Reader(const StringPtr& value): StringPtr(value) {}


  template <typename T, typename = decltype(kj::instance<T>().c_str())>
  inline Reader(const T& t): StringPtr(t) {}




};

class Data::Builder: public kj::ArrayPtr<byte> {


public:
  typedef Data Builds;

  Builder() = default;
  inline Builder(decltype(nullptr)): ArrayPtr<byte>(nullptr) {}
  inline Builder(byte* value, size_t size): ArrayPtr<byte>(value, size) {}
  inline Builder(kj::Array<byte>& value): ArrayPtr<byte>(value) {}
  inline Builder(ArrayPtr<byte> value): ArrayPtr<byte>(value) {}

  inline Data::Reader asReader() const { return Data::Reader(*this); }
  inline operator Reader() const { return asReader(); }
};

class Text::Builder: public kj::DisallowConstCopy {


public:
  inline Builder(): content(nulstr, 1) {}
  inline Builder(decltype(nullptr)): content(nulstr, 1) {}
  inline Builder(char* value): content(value, strlen(value) + 1) {}
  inline Builder(char* value, size_t size): content(value, size + 1) {
                                                                         ;
  }

  inline Reader asReader() const { return Reader(content.begin(), content.size() - 1); }
  inline operator Reader() const { return asReader(); }

  inline operator kj::ArrayPtr<char>();
  inline kj::ArrayPtr<char> asArray();
  inline operator kj::ArrayPtr<const char>() const;
  inline kj::ArrayPtr<const char> asArray() const;
  inline kj::ArrayPtr<byte> asBytes() { return asArray().asBytes(); }
  inline kj::ArrayPtr<const byte> asBytes() const { return asArray().asBytes(); }


  inline operator kj::StringPtr() const;
  inline kj::StringPtr asString() const;

  inline const char* cStr() const { return content.begin(); }


  inline size_t size() const { return content.size() - 1; }


  inline char operator[](size_t index) const { return content[index]; }
  inline char& operator[](size_t index) { return content[index]; }

  inline char* begin() { return content.begin(); }
  inline char* end() { return content.end() - 1; }
  inline const char* begin() const { return content.begin(); }
  inline const char* end() const { return content.end() - 1; }

  inline bool operator==(decltype(nullptr)) const { return content.size() <= 1; }
  inline bool operator!=(decltype(nullptr)) const { return content.size() > 1; }

  inline bool operator==(Builder other) const { return asString() == other.asString(); }
  inline bool operator!=(Builder other) const { return asString() != other.asString(); }
  inline bool operator< (Builder other) const { return asString() < other.asString(); }
  inline bool operator> (Builder other) const { return asString() > other.asString(); }
  inline bool operator<=(Builder other) const { return asString() <= other.asString(); }
  inline bool operator>=(Builder other) const { return asString() >= other.asString(); }

  inline kj::StringPtr slice(size_t start) const;
  inline kj::ArrayPtr<const char> slice(size_t start, size_t end) const;
  inline Builder slice(size_t start);
  inline kj::ArrayPtr<char> slice(size_t start, size_t end);



private:
  inline explicit Builder(kj::ArrayPtr<char> content): content(content) {}

  kj::ArrayPtr<char> content;

  static char nulstr[1];
};

inline kj::StringPtr operator*(::kj::_::Stringifier, Text::Builder builder) {
  return builder.asString();
}

inline bool operator==(const char* a, const Text::Builder& b) { return a == b.asString(); }
inline bool operator!=(const char* a, const Text::Builder& b) { return a != b.asString(); }

inline Text::Builder::operator kj::StringPtr() const {
  return kj::StringPtr(content.begin(), content.size() - 1);
}

inline kj::StringPtr Text::Builder::asString() const {
  return kj::StringPtr(content.begin(), content.size() - 1);
}

inline Text::Builder::operator kj::ArrayPtr<char>() {
  return content.slice(0, content.size() - 1);
}

inline kj::ArrayPtr<char> Text::Builder::asArray() {
  return content.slice(0, content.size() - 1);
}

inline Text::Builder::operator kj::ArrayPtr<const char>() const {
  return content.slice(0, content.size() - 1);
}

inline kj::ArrayPtr<const char> Text::Builder::asArray() const {
  return content.slice(0, content.size() - 1);
}

inline kj::StringPtr Text::Builder::slice(size_t start) const {
  return asReader().slice(start);
}
inline kj::ArrayPtr<const char> Text::Builder::slice(size_t start, size_t end) const {
  return content.slice(start, end);
}

inline Text::Builder Text::Builder::slice(size_t start) {
  return Text::Builder(content.slice(start, content.size()));
}
inline kj::ArrayPtr<char> Text::Builder::slice(size_t start, size_t end) {
  return content.slice(start, end);
}

}
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/endian.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/endian.h" 3
#define CAPNP_ENDIAN_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/endian.h" 3






namespace capnp {
namespace _ {
# 68 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/endian.h" 3
#define CAPNP_WIRE_BYTE_ORDER __ORDER_LITTLE_ENDIAN__
#define CAPNP_OPPOSITE_OF_WIRE_BYTE_ORDER __ORDER_BIG_ENDIAN__







template <typename T>
class DirectWireValue {
public:
  inline T get() const __attribute__((always_inline)) { return value; }
  inline void set(T newValue) __attribute__((always_inline)) { value = newValue; }

private:
  T value;
};

template <typename T>
using WireValue = DirectWireValue<T>;
# 306 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/endian.h" 3
}
}
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 2 3
# 61 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3
namespace capnp {


class ClientHook;


namespace _ {

class PointerBuilder;
class PointerReader;
class StructBuilder;
class StructReader;
class ListBuilder;
class ListReader;
class OrphanBuilder;
struct WirePointer;
struct WireHelpers;
class SegmentReader;
class SegmentBuilder;
class Arena;
class BuilderArena;






typedef uint BitsPerElementTableType;


static constexpr BitsPerElementTableType BITS_PER_ELEMENT_TABLE[8] = {
  bounded< 0>() * BITS / ELEMENTS,
  bounded< 1>() * BITS / ELEMENTS,
  bounded< 8>() * BITS / ELEMENTS,
  bounded<16>() * BITS / ELEMENTS,
  bounded<32>() * BITS / ELEMENTS,
  bounded<64>() * BITS / ELEMENTS,
  bounded< 0>() * BITS / ELEMENTS,
  bounded< 0>() * BITS / ELEMENTS
};

inline constexpr BitsPerElementTableType dataBitsPerElement(ElementSize size) {
  return _::BITS_PER_ELEMENT_TABLE[static_cast<int>(size)];
}

inline constexpr PointersPerElementN<1> pointersPerElement(ElementSize size) {
  return size == ElementSize::POINTER
      ? PointersPerElementN<1>(ONE * POINTERS / ELEMENTS)
      : PointersPerElementN<1>(ZERO * POINTERS / ELEMENTS);
}

static constexpr BitsPerElementTableType BITS_PER_ELEMENT_INCLUDING_PONITERS_TABLE[8] = {
  bounded< 0>() * BITS / ELEMENTS,
  bounded< 1>() * BITS / ELEMENTS,
  bounded< 8>() * BITS / ELEMENTS,
  bounded<16>() * BITS / ELEMENTS,
  bounded<32>() * BITS / ELEMENTS,
  bounded<64>() * BITS / ELEMENTS,
  bounded<64>() * BITS / ELEMENTS,
  bounded< 0>() * BITS / ELEMENTS
};

inline constexpr BitsPerElementTableType bitsPerElementIncludingPointers(ElementSize size) {
  return _::BITS_PER_ELEMENT_INCLUDING_PONITERS_TABLE[static_cast<int>(size)];
}

template <size_t size> struct ElementSizeForByteSize;
template <> struct ElementSizeForByteSize<1> { static constexpr ElementSize value = ElementSize::BYTE; };
template <> struct ElementSizeForByteSize<2> { static constexpr ElementSize value = ElementSize::TWO_BYTES; };
template <> struct ElementSizeForByteSize<4> { static constexpr ElementSize value = ElementSize::FOUR_BYTES; };
template <> struct ElementSizeForByteSize<8> { static constexpr ElementSize value = ElementSize::EIGHT_BYTES; };

template <typename T> struct ElementSizeForType {
  static constexpr ElementSize value =

      ::capnp::kind<T>() == Kind::PRIMITIVE ? ElementSizeForByteSize<sizeof(T)>::value :
      ::capnp::kind<T>() == Kind::ENUM ? ElementSize::TWO_BYTES :
      ::capnp::kind<T>() == Kind::STRUCT ? ElementSize::INLINE_COMPOSITE :


      ElementSize::POINTER;
};


template <> struct ElementSizeForType<Void> { static constexpr ElementSize value = ElementSize::VOID; };
template <> struct ElementSizeForType<bool> { static constexpr ElementSize value = ElementSize::BIT; };


template <typename T, Kind K> struct ElementSizeForType<List<T, K>> {
  static constexpr ElementSize value = ElementSize::POINTER;
};
template <> struct ElementSizeForType<Text> {
  static constexpr ElementSize value = ElementSize::POINTER;
};
template <> struct ElementSizeForType<Data> {
  static constexpr ElementSize value = ElementSize::POINTER;
};

template <typename T>
inline constexpr ElementSize elementSizeForType() {
  return ElementSizeForType<T>::value;
}

struct MessageSizeCounts {
  WordCountN<61, uint64_t> wordCount;
  uint capCount;

  MessageSizeCounts& operator+=(const MessageSizeCounts& other) {


    wordCount = assumeBits<61>(wordCount + other.wordCount);
    capCount += other.capCount;
    return *this;
  }

  void addWords(WordCountN<61, uint64_t> other) {
    wordCount = assumeBits<61>(wordCount + other);
  }

  MessageSize asPublic() {
    return MessageSize { unbound(wordCount / WORDS), capCount };
  }
};



template <int wordCount>
union AlignedData {



  uint8_t bytes[wordCount * sizeof(word)];
  word words[wordCount];
};

struct StructSize {
  StructDataWordCount data;
  StructPointerCount pointers;

  inline constexpr WordCountN<17> total() const { return data + pointers * WORDS_PER_POINTER; }

  StructSize() = default;
  inline constexpr StructSize(StructDataWordCount data, StructPointerCount pointers)
      : data(data), pointers(pointers) {}
};

template <typename T, typename CapnpPrivate = typename T::_capnpPrivate>
inline constexpr StructSize structSize() {
  return StructSize(bounded(CapnpPrivate::dataWordSize) * WORDS,
                    bounded(CapnpPrivate::pointerCount) * POINTERS);
}

template <typename T, typename CapnpPrivate = typename T::_capnpPrivate,
          typename = kj::EnableIf< ::capnp::kind<T>() == Kind::STRUCT>>
inline constexpr StructSize minStructSizeForElement() {



  return StructSize(bounded(CapnpPrivate::dataWordSize) * WORDS,
                    bounded(CapnpPrivate::pointerCount) * POINTERS);
}

template <typename T, typename = kj::EnableIf< ::capnp::kind<T>() != Kind::STRUCT>>
inline constexpr StructSize minStructSizeForElement() {



  return StructSize(
      dataBitsPerElement(elementSizeForType<T>()) * ELEMENTS > ZERO * BITS
          ? StructDataWordCount(ONE * WORDS) : StructDataWordCount(ZERO * WORDS),
      pointersPerElement(elementSizeForType<T>()) * ELEMENTS);
}




template <typename T, Kind kind = ::capnp::kind<T>()> struct Mask_;
template <typename T> struct Mask_<T, Kind::PRIMITIVE> { typedef T Type; };
template <typename T> struct Mask_<T, Kind::ENUM> { typedef uint16_t Type; };
template <> struct Mask_<float, Kind::PRIMITIVE> { typedef uint32_t Type; };
template <> struct Mask_<double, Kind::PRIMITIVE> { typedef uint64_t Type; };

template <typename T> struct Mask_<T, Kind::OTHER> {

  static_assert(sizeof(T) == 2, "Don't know how to mask this type.");
  typedef uint16_t Type;
};

template <typename T>
using Mask = typename Mask_<T>::Type;

template <typename T>
inline Mask<T> mask(T value, Mask<T> mask) __attribute__((always_inline));
template <typename T>
inline T unmask(Mask<T> value, Mask<T> mask) __attribute__((always_inline));

template <typename T>
inline Mask<T> mask(T value, Mask<T> mask) {
  return static_cast<Mask<T> >(value) ^ mask;
}

template <>
inline uint32_t mask<float>(float value, uint32_t mask) {






  uint32_t i;
  static_assert(sizeof(i) == sizeof(value), "float is not 32 bits?");
  memcpy(&i, &value, sizeof(value));
  return i ^ mask;
}

template <>
inline uint64_t mask<double>(double value, uint64_t mask) {






  uint64_t i;
  static_assert(sizeof(i) == sizeof(value), "double is not 64 bits?");
  memcpy(&i, &value, sizeof(value));
  return i ^ mask;
}

template <typename T>
inline T unmask(Mask<T> value, Mask<T> mask) {
  return static_cast<T>(value ^ mask);
}

template <>
inline float unmask<float>(uint32_t value, uint32_t mask) {
  value ^= mask;
  float result;
  static_assert(sizeof(result) == sizeof(value), "float is not 32 bits?");
  memcpy(&result, &value, sizeof(value));
  return result;
}

template <>
inline double unmask<double>(uint64_t value, uint64_t mask) {
  value ^= mask;
  double result;
  static_assert(sizeof(result) == sizeof(value), "double is not 64 bits?");
  memcpy(&result, &value, sizeof(value));
  return result;
}



class CapTableReader {
public:

  virtual kj::Maybe<kj::Own<ClientHook>> extractCap(uint index) = 0;


};

class CapTableBuilder: public CapTableReader {
public:

  virtual uint injectCap(kj::Own<ClientHook>&& cap) = 0;




  virtual void dropCap(uint index) = 0;


};



class PointerBuilder: public kj::DisallowConstCopy {


public:
  inline PointerBuilder(): segment(nullptr), capTable(nullptr), pointer(nullptr) {}

  static inline PointerBuilder getRoot(
      SegmentBuilder* segment, CapTableBuilder* capTable, word* location);



  inline bool isNull() { return getPointerType() == PointerType::NULL_; }
  PointerType getPointerType() const;

  StructBuilder getStruct(StructSize size, const word* defaultValue);
  ListBuilder getList(ElementSize elementSize, const word* defaultValue);
  ListBuilder getStructList(StructSize elementSize, const word* defaultValue);
  ListBuilder getListAnySize(const word* defaultValue);
  template <typename T> typename T::Builder getBlob(
      const void* defaultValue, ByteCount defaultSize);

  kj::Own<ClientHook> getCapability();





  StructBuilder initStruct(StructSize size);
  ListBuilder initList(ElementSize elementSize, ElementCount elementCount);
  ListBuilder initStructList(ElementCount elementCount, StructSize size);
  template <typename T> typename T::Builder initBlob(ByteCount size);



  void setStruct(const StructReader& value, bool canonical = false);
  void setList(const ListReader& value, bool canonical = false);
  template <typename T> void setBlob(typename T::Reader value);

  void setCapability(kj::Own<ClientHook>&& cap);




  void adopt(OrphanBuilder&& orphan);


  OrphanBuilder disown();


  void clear();


  void transferFrom(PointerBuilder other);


  void copyFrom(PointerReader other, bool canonical = false);




  PointerReader asReader() const;

  BuilderArena* getArena() const;


  CapTableBuilder* getCapTable();


  PointerBuilder imbue(CapTableBuilder* capTable);


private:
  SegmentBuilder* segment;
  CapTableBuilder* capTable;
  WirePointer* pointer;

  inline PointerBuilder(SegmentBuilder* segment, CapTableBuilder* capTable, WirePointer* pointer)
      : segment(segment), capTable(capTable), pointer(pointer) {}

  friend class StructBuilder;
  friend class ListBuilder;
  friend class OrphanBuilder;
};

class PointerReader {
public:
  inline PointerReader()
      : segment(nullptr), capTable(nullptr), pointer(nullptr), nestingLimit(0x7fffffff) {}

  static PointerReader getRoot(SegmentReader* segment, CapTableReader* capTable,
                               const word* location, int nestingLimit);



  static inline PointerReader getRootUnchecked(const word* location);


  MessageSizeCounts targetSize() const;






  inline bool isNull() const { return getPointerType() == PointerType::NULL_; }
  PointerType getPointerType() const;

  StructReader getStruct(const word* defaultValue) const;
  ListReader getList(ElementSize expectedElementSize, const word* defaultValue) const;
  ListReader getListAnySize(const word* defaultValue) const;
  template <typename T>
  typename T::Reader getBlob(const void* defaultValue, ByteCount defaultSize) const;

  kj::Own<ClientHook> getCapability() const;





  const word* getUnchecked() const;




  kj::Maybe<Arena&> getArena() const;


  CapTableReader* getCapTable();


  PointerReader imbue(CapTableReader* capTable) const;


  bool isCanonical(const word **readHead);






private:
  SegmentReader* segment;
  CapTableReader* capTable;
  const WirePointer* pointer;

  int nestingLimit;



  inline PointerReader(SegmentReader* segment, CapTableReader* capTable,
                       const WirePointer* pointer, int nestingLimit)
      : segment(segment), capTable(capTable), pointer(pointer), nestingLimit(nestingLimit) {}

  friend class StructReader;
  friend class ListReader;
  friend class PointerBuilder;
  friend class OrphanBuilder;
};



class StructBuilder: public kj::DisallowConstCopy {
public:
  inline StructBuilder(): segment(nullptr), capTable(nullptr), data(nullptr), pointers(nullptr) {}

  inline word* getLocation() { return reinterpret_cast<word*>(data); }



  inline StructDataBitCount getDataSectionSize() const { return dataSize; }
  inline StructPointerCount getPointerSectionSize() const { return pointerCount; }
  inline kj::ArrayPtr<byte> getDataSectionAsBlob();
  inline _::ListBuilder getPointerSectionAsList();

  template <typename T>
  inline bool hasDataField(StructDataOffset offset) __attribute__((always_inline));


  template <typename T>
  inline T getDataField(StructDataOffset offset) __attribute__((always_inline));



  template <typename T>
  inline T getDataField(StructDataOffset offset, Mask<T> mask) __attribute__((always_inline));



  template <typename T>
  inline void setDataField(StructDataOffset offset, kj::NoInfer<T> value) __attribute__((always_inline));


  template <typename T>
  inline void setDataField(StructDataOffset offset, kj::NoInfer<T> value, Mask<T> mask) __attribute__((always_inline));




  inline PointerBuilder getPointerField(StructPointerOffset ptrIndex) __attribute__((always_inline));


  void clearAll();


  void transferContentFrom(StructBuilder other);




  void copyContentFrom(StructReader other);




  StructReader asReader() const;


  BuilderArena* getArena();


  CapTableBuilder* getCapTable();


  StructBuilder imbue(CapTableBuilder* capTable);


private:
  SegmentBuilder* segment;
  CapTableBuilder* capTable;
  void* data;
  WirePointer* pointers;

  StructDataBitCount dataSize;



  StructPointerCount pointerCount;

  inline StructBuilder(SegmentBuilder* segment, CapTableBuilder* capTable,
                       void* data, WirePointer* pointers,
                       StructDataBitCount dataSize, StructPointerCount pointerCount)
      : segment(segment), capTable(capTable), data(data), pointers(pointers),
        dataSize(dataSize), pointerCount(pointerCount) {}

  friend class ListBuilder;
  friend struct WireHelpers;
  friend class OrphanBuilder;
};

class StructReader {
public:
  inline StructReader()
      : segment(nullptr), capTable(nullptr), data(nullptr), pointers(nullptr),
        dataSize(ZERO * BITS), pointerCount(ZERO * POINTERS), nestingLimit(0x7fffffff) {}
  inline StructReader(kj::ArrayPtr<const word> data)
      : segment(nullptr), capTable(nullptr), data(data.begin()), pointers(nullptr),
        dataSize(assumeBits<STRUCT_DATA_WORD_COUNT_BITS>(data.size()) * WORDS * BITS_PER_WORD),
        pointerCount(ZERO * POINTERS), nestingLimit(0x7fffffff) {}

  const void* getLocation() const { return data; }

  inline StructDataBitCount getDataSectionSize() const { return dataSize; }
  inline StructPointerCount getPointerSectionSize() const { return pointerCount; }
  inline kj::ArrayPtr<const byte> getDataSectionAsBlob();
  inline _::ListReader getPointerSectionAsList();

  kj::Array<word> canonicalize();

  template <typename T>
  inline bool hasDataField(StructDataOffset offset) const __attribute__((always_inline));


  template <typename T>
  inline T getDataField(StructDataOffset offset) const __attribute__((always_inline));




  template <typename T>
  inline T getDataField(StructDataOffset offset, Mask<T> mask) const __attribute__((always_inline));



  inline PointerReader getPointerField(StructPointerOffset ptrIndex) const __attribute__((always_inline));



  MessageSizeCounts totalSize() const;






  CapTableReader* getCapTable();


  StructReader imbue(CapTableReader* capTable) const;


  bool isCanonical(const word **readHead, const word **ptrHead,
                   bool *dataTrunc, bool *ptrTrunc);
# 653 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3
private:
  SegmentReader* segment;
  CapTableReader* capTable;

  const void* data;
  const WirePointer* pointers;

  StructDataBitCount dataSize;



  StructPointerCount pointerCount;

  int nestingLimit;




  inline StructReader(SegmentReader* segment, CapTableReader* capTable,
                      const void* data, const WirePointer* pointers,
                      StructDataBitCount dataSize, StructPointerCount pointerCount,
                      int nestingLimit)
      : segment(segment), capTable(capTable), data(data), pointers(pointers),
        dataSize(dataSize), pointerCount(pointerCount),
        nestingLimit(nestingLimit) {}

  friend class ListReader;
  friend class StructBuilder;
  friend struct WireHelpers;
};



class ListBuilder: public kj::DisallowConstCopy {
public:
  inline explicit ListBuilder(ElementSize elementSize)
      : segment(nullptr), capTable(nullptr), ptr(nullptr), elementCount(ZERO * ELEMENTS),
        step(ZERO * BITS / ELEMENTS), structDataSize(ZERO * BITS),
        structPointerCount(ZERO * POINTERS), elementSize(elementSize) {}

  inline word* getLocation() {


    if (elementSize == ElementSize::INLINE_COMPOSITE && ptr != nullptr) {
      return reinterpret_cast<word*>(ptr) - POINTER_SIZE_IN_WORDS;
    } else {
      return reinterpret_cast<word*>(ptr);
    }
  }

  inline ElementSize getElementSize() const { return elementSize; }

  inline ListElementCount size() const;


  Text::Builder asText();
  Data::Builder asData();


  template <typename T>
  inline T getDataElement(ElementCount index) __attribute__((always_inline));


  template <typename T>
  inline void setDataElement(ElementCount index, kj::NoInfer<T> value) __attribute__((always_inline));


  inline PointerBuilder getPointerElement(ElementCount index) __attribute__((always_inline));

  StructBuilder getStructElement(ElementCount index);

  ListReader asReader() const;


  BuilderArena* getArena();


  CapTableBuilder* getCapTable();


  ListBuilder imbue(CapTableBuilder* capTable);


private:
  SegmentBuilder* segment;
  CapTableBuilder* capTable;

  byte* ptr;

  ListElementCount elementCount;

  BitsPerElementN<23> step;



  StructDataBitCount structDataSize;
  StructPointerCount structPointerCount;



  ElementSize elementSize;



  inline ListBuilder(SegmentBuilder* segment, CapTableBuilder* capTable, void* ptr,
                     BitsPerElementN<23> step, ListElementCount size,
                     StructDataBitCount structDataSize, StructPointerCount structPointerCount,
                     ElementSize elementSize)
      : segment(segment), capTable(capTable), ptr(reinterpret_cast<byte*>(ptr)),
        elementCount(size), step(step), structDataSize(structDataSize),
        structPointerCount(structPointerCount), elementSize(elementSize) {}

  friend class StructBuilder;
  friend struct WireHelpers;
  friend class OrphanBuilder;
};

class ListReader {
public:
  inline explicit ListReader(ElementSize elementSize)
      : segment(nullptr), capTable(nullptr), ptr(nullptr), elementCount(ZERO * ELEMENTS),
        step(ZERO * BITS / ELEMENTS), structDataSize(ZERO * BITS),
        structPointerCount(ZERO * POINTERS), elementSize(elementSize), nestingLimit(0x7fffffff) {}

  inline ListElementCount size() const;


  inline ElementSize getElementSize() const { return elementSize; }

  Text::Reader asText();
  Data::Reader asData();


  kj::ArrayPtr<const byte> asRawBytes();

  template <typename T>
  inline T getDataElement(ElementCount index) const __attribute__((always_inline));


  inline PointerReader getPointerElement(ElementCount index) const __attribute__((always_inline));

  StructReader getStructElement(ElementCount index) const;

  CapTableReader* getCapTable();


  ListReader imbue(CapTableReader* capTable) const;


  bool isCanonical(const word **readHead, const WirePointer* ref);






private:
  SegmentReader* segment;
  CapTableReader* capTable;

  const byte* ptr;

  ListElementCount elementCount;

  BitsPerElementN<23> step;



  StructDataBitCount structDataSize;
  StructPointerCount structPointerCount;



  ElementSize elementSize;



  int nestingLimit;



  inline ListReader(SegmentReader* segment, CapTableReader* capTable, const void* ptr,
                    ListElementCount elementCount, BitsPerElementN<23> step,
                    StructDataBitCount structDataSize, StructPointerCount structPointerCount,
                    ElementSize elementSize, int nestingLimit)
      : segment(segment), capTable(capTable), ptr(reinterpret_cast<const byte*>(ptr)),
        elementCount(elementCount), step(step), structDataSize(structDataSize),
        structPointerCount(structPointerCount), elementSize(elementSize),
        nestingLimit(nestingLimit) {}

  friend class StructReader;
  friend class ListBuilder;
  friend struct WireHelpers;
  friend class OrphanBuilder;
};



class OrphanBuilder {
public:
  inline OrphanBuilder(): segment(nullptr), capTable(nullptr), location(nullptr) {
    memset(&tag, 0, sizeof(tag));
  }
  OrphanBuilder(const OrphanBuilder& other) = delete;
  inline OrphanBuilder(OrphanBuilder&& other) noexcept;
  inline ~OrphanBuilder() noexcept(false);

  static OrphanBuilder initStruct(BuilderArena* arena, CapTableBuilder* capTable, StructSize size);
  static OrphanBuilder initList(BuilderArena* arena, CapTableBuilder* capTable,
                                ElementCount elementCount, ElementSize elementSize);
  static OrphanBuilder initStructList(BuilderArena* arena, CapTableBuilder* capTable,
                                      ElementCount elementCount, StructSize elementSize);
  static OrphanBuilder initText(BuilderArena* arena, CapTableBuilder* capTable, ByteCount size);
  static OrphanBuilder initData(BuilderArena* arena, CapTableBuilder* capTable, ByteCount size);

  static OrphanBuilder copy(BuilderArena* arena, CapTableBuilder* capTable, StructReader copyFrom);
  static OrphanBuilder copy(BuilderArena* arena, CapTableBuilder* capTable, ListReader copyFrom);
  static OrphanBuilder copy(BuilderArena* arena, CapTableBuilder* capTable, PointerReader copyFrom);
  static OrphanBuilder copy(BuilderArena* arena, CapTableBuilder* capTable, Text::Reader copyFrom);
  static OrphanBuilder copy(BuilderArena* arena, CapTableBuilder* capTable, Data::Reader copyFrom);

  static OrphanBuilder copy(BuilderArena* arena, CapTableBuilder* capTable,
                            kj::Own<ClientHook> copyFrom);


  static OrphanBuilder concat(BuilderArena* arena, CapTableBuilder* capTable,
                              ElementSize expectedElementSize, StructSize expectedStructSize,
                              kj::ArrayPtr<const ListReader> lists);

  static OrphanBuilder referenceExternalData(BuilderArena* arena, Data::Reader data);

  OrphanBuilder& operator=(const OrphanBuilder& other) = delete;
  inline OrphanBuilder& operator=(OrphanBuilder&& other);

  inline bool operator==(decltype(nullptr)) const { return location == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return location != nullptr; }

  StructBuilder asStruct(StructSize size);


  ListBuilder asList(ElementSize elementSize);



  ListBuilder asStructList(StructSize elementSize);


  ListBuilder asListAnySize();


  Text::Builder asText();
  Data::Builder asData();


  StructReader asStructReader(StructSize size) const;
  ListReader asListReader(ElementSize elementSize) const;
  ListReader asListReaderAnySize() const;

  kj::Own<ClientHook> asCapability() const;

  Text::Reader asTextReader() const;
  Data::Reader asDataReader() const;

  bool truncate(ElementCount size, bool isText) __attribute__((warn_unused_result));



  void truncate(ElementCount size, ElementSize elementSize);
  void truncate(ElementCount size, StructSize elementSize);
  void truncateText(ElementCount size);


private:
  static_assert(ONE * POINTERS * WORDS_PER_POINTER == ONE * WORDS,
                "This struct assumes a pointer is one word.");
  word tag;
# 940 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3
  SegmentBuilder* segment;


  CapTableBuilder* capTable;


  word* location;



  inline OrphanBuilder(const void* tagPtr, SegmentBuilder* segment,
                       CapTableBuilder* capTable, word* location)
      : segment(segment), capTable(capTable), location(location) {
    memcpy(&tag, tagPtr, sizeof(tag));
  }

  inline WirePointer* tagAsPtr() { return reinterpret_cast<WirePointer*>(&tag); }
  inline const WirePointer* tagAsPtr() const { return reinterpret_cast<const WirePointer*>(&tag); }

  void euthanize();



  friend struct WireHelpers;
};





template <> typename Text::Builder PointerBuilder::initBlob<Text>(ByteCount size);
template <> void PointerBuilder::setBlob<Text>(typename Text::Reader value);
template <> typename Text::Builder PointerBuilder::getBlob<Text>(
    const void* defaultValue, ByteCount defaultSize);
template <> typename Text::Reader PointerReader::getBlob<Text>(
    const void* defaultValue, ByteCount defaultSize) const;

template <> typename Data::Builder PointerBuilder::initBlob<Data>(ByteCount size);
template <> void PointerBuilder::setBlob<Data>(typename Data::Reader value);
template <> typename Data::Builder PointerBuilder::getBlob<Data>(
    const void* defaultValue, ByteCount defaultSize);
template <> typename Data::Reader PointerReader::getBlob<Data>(
    const void* defaultValue, ByteCount defaultSize) const;

inline PointerBuilder PointerBuilder::getRoot(
    SegmentBuilder* segment, CapTableBuilder* capTable, word* location) {
  return PointerBuilder(segment, capTable, reinterpret_cast<WirePointer*>(location));
}

inline PointerReader PointerReader::getRootUnchecked(const word* location) {
  return PointerReader(nullptr, nullptr,
                       reinterpret_cast<const WirePointer*>(location), 0x7fffffff);
}



inline kj::ArrayPtr<byte> StructBuilder::getDataSectionAsBlob() {
  return kj::ArrayPtr<byte>(reinterpret_cast<byte*>(data),
      unbound(dataSize / BITS_PER_BYTE / BYTES));
}

inline _::ListBuilder StructBuilder::getPointerSectionAsList() {
  return _::ListBuilder(segment, capTable, pointers, ONE * POINTERS * BITS_PER_POINTER / ELEMENTS,
                        pointerCount * (ONE * ELEMENTS / POINTERS),
                        ZERO * BITS, ONE * POINTERS, ElementSize::POINTER);
}

template <typename T>
inline bool StructBuilder::hasDataField(StructDataOffset offset) {
  return getDataField<Mask<T>>(offset) != 0;
}

template <>
inline bool StructBuilder::hasDataField<Void>(StructDataOffset offset) {
  return false;
}

template <typename T>
inline T StructBuilder::getDataField(StructDataOffset offset) {
  return reinterpret_cast<WireValue<T>*>(data)[unbound(offset / ELEMENTS)].get();
}

template <>
inline bool StructBuilder::getDataField<bool>(StructDataOffset offset) {
  BitCount32 boffset = offset * (ONE * BITS / ELEMENTS);
  byte* b = reinterpret_cast<byte*>(data) + boffset / BITS_PER_BYTE;
  return (*reinterpret_cast<uint8_t*>(b) &
      unbound(ONE << (boffset % BITS_PER_BYTE / BITS))) != 0;
}

template <>
inline Void StructBuilder::getDataField<Void>(StructDataOffset offset) {
  return VOID;
}

template <typename T>
inline T StructBuilder::getDataField(StructDataOffset offset, Mask<T> mask) {
  return unmask<T>(getDataField<Mask<T> >(offset), mask);
}

template <typename T>
inline void StructBuilder::setDataField(StructDataOffset offset, kj::NoInfer<T> value) {
  reinterpret_cast<WireValue<T>*>(data)[unbound(offset / ELEMENTS)].set(value);
}
# 1057 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3
template <>
inline void StructBuilder::setDataField<bool>(StructDataOffset offset, bool value) {
  auto boffset = offset * (ONE * BITS / ELEMENTS);
  byte* b = reinterpret_cast<byte*>(data) + boffset / BITS_PER_BYTE;
  uint bitnum = unboundMaxBits<3>(boffset % BITS_PER_BYTE / BITS);
  *reinterpret_cast<uint8_t*>(b) = (*reinterpret_cast<uint8_t*>(b) & ~(1 << bitnum))
                                 | (static_cast<uint8_t>(value) << bitnum);
}

template <>
inline void StructBuilder::setDataField<Void>(StructDataOffset offset, Void value) {}

template <typename T>
inline void StructBuilder::setDataField(StructDataOffset offset,
                                        kj::NoInfer<T> value, Mask<T> m) {
  setDataField<Mask<T> >(offset, mask<T>(value, m));
}

inline PointerBuilder StructBuilder::getPointerField(StructPointerOffset ptrIndex) {

  return PointerBuilder(segment, capTable, reinterpret_cast<WirePointer*>(
      reinterpret_cast<word*>(pointers) + ptrIndex * WORDS_PER_POINTER));
}



inline kj::ArrayPtr<const byte> StructReader::getDataSectionAsBlob() {
  return kj::ArrayPtr<const byte>(reinterpret_cast<const byte*>(data),
      unbound(dataSize / BITS_PER_BYTE / BYTES));
}

inline _::ListReader StructReader::getPointerSectionAsList() {
  return _::ListReader(segment, capTable, pointers, pointerCount * (ONE * ELEMENTS / POINTERS),
                       ONE * POINTERS * BITS_PER_POINTER / ELEMENTS, ZERO * BITS, ONE * POINTERS,
                       ElementSize::POINTER, nestingLimit);
}

template <typename T>
inline bool StructReader::hasDataField(StructDataOffset offset) const {
  return getDataField<Mask<T>>(offset) != 0;
}

template <>
inline bool StructReader::hasDataField<Void>(StructDataOffset offset) const {
  return false;
}

template <typename T>
inline T StructReader::getDataField(StructDataOffset offset) const {
  if ((offset + ONE * ELEMENTS) * capnp::bitsPerElement<T>() <= dataSize) {
    return reinterpret_cast<const WireValue<T>*>(data)[unbound(offset / ELEMENTS)].get();
  } else {
    return static_cast<T>(0);
  }
}

template <>
inline bool StructReader::getDataField<bool>(StructDataOffset offset) const {
  auto boffset = offset * (ONE * BITS / ELEMENTS);
  if (boffset < dataSize) {
    const byte* b = reinterpret_cast<const byte*>(data) + boffset / BITS_PER_BYTE;
    return (*reinterpret_cast<const uint8_t*>(b) &
        unbound(ONE << (boffset % BITS_PER_BYTE / BITS))) != 0;
  } else {
    return false;
  }
}

template <>
inline Void StructReader::getDataField<Void>(StructDataOffset offset) const {
  return VOID;
}

template <typename T>
T StructReader::getDataField(StructDataOffset offset, Mask<T> mask) const {
  return unmask<T>(getDataField<Mask<T> >(offset), mask);
}

inline PointerReader StructReader::getPointerField(StructPointerOffset ptrIndex) const {
  if (ptrIndex < pointerCount) {

    return PointerReader(segment, capTable, reinterpret_cast<const WirePointer*>(
        reinterpret_cast<const word*>(pointers) + ptrIndex * WORDS_PER_POINTER), nestingLimit);
  } else{
    return PointerReader();
  }
}



inline ListElementCount ListBuilder::size() const { return elementCount; }

template <typename T>
inline T ListBuilder::getDataElement(ElementCount index) {
  return reinterpret_cast<WireValue<T>*>(
      ptr + upgradeBound<uint64_t>(index) * step / BITS_PER_BYTE)->get();







}

template <>
inline bool ListBuilder::getDataElement<bool>(ElementCount index) {

  auto bindex = index * (ONE * BITS / ELEMENTS);
  byte* b = ptr + bindex / BITS_PER_BYTE;
  return (*reinterpret_cast<uint8_t*>(b) &
      unbound(ONE << (bindex % BITS_PER_BYTE / BITS))) != 0;
}

template <>
inline Void ListBuilder::getDataElement<Void>(ElementCount index) {
  return VOID;
}

template <typename T>
inline void ListBuilder::setDataElement(ElementCount index, kj::NoInfer<T> value) {
  reinterpret_cast<WireValue<T>*>(
      ptr + upgradeBound<uint64_t>(index) * step / BITS_PER_BYTE)->set(value);
}
# 1194 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/layout.h" 3
template <>
inline void ListBuilder::setDataElement<bool>(ElementCount index, bool value) {

  auto bindex = index * (ONE * BITS / ELEMENTS);
  byte* b = ptr + bindex / BITS_PER_BYTE;
  auto bitnum = bindex % BITS_PER_BYTE / BITS;
  *reinterpret_cast<uint8_t*>(b) = (*reinterpret_cast<uint8_t*>(b) & ~(1 << unbound(bitnum)))
                                 | (static_cast<uint8_t>(value) << unbound(bitnum));
}

template <>
inline void ListBuilder::setDataElement<Void>(ElementCount index, Void value) {}

inline PointerBuilder ListBuilder::getPointerElement(ElementCount index) {
  return PointerBuilder(segment, capTable, reinterpret_cast<WirePointer*>(ptr +
      upgradeBound<uint64_t>(index) * step / BITS_PER_BYTE));
}



inline ListElementCount ListReader::size() const { return elementCount; }

template <typename T>
inline T ListReader::getDataElement(ElementCount index) const {
  return reinterpret_cast<const WireValue<T>*>(
      ptr + upgradeBound<uint64_t>(index) * step / BITS_PER_BYTE)->get();
}

template <>
inline bool ListReader::getDataElement<bool>(ElementCount index) const {

  auto bindex = index * (ONE * BITS / ELEMENTS);
  const byte* b = ptr + bindex / BITS_PER_BYTE;
  return (*reinterpret_cast<const uint8_t*>(b) &
      unbound(ONE << (bindex % BITS_PER_BYTE / BITS))) != 0;
}

template <>
inline Void ListReader::getDataElement<Void>(ElementCount index) const {
  return VOID;
}

inline PointerReader ListReader::getPointerElement(ElementCount index) const {
  return PointerReader(segment, capTable, reinterpret_cast<const WirePointer*>(
      ptr + upgradeBound<uint64_t>(index) * step / BITS_PER_BYTE), nestingLimit);
}



inline OrphanBuilder::OrphanBuilder(OrphanBuilder&& other) noexcept
    : segment(other.segment), capTable(other.capTable), location(other.location) {
  memcpy(&tag, &other.tag, sizeof(tag));
  other.segment = nullptr;
  other.location = nullptr;
}

inline OrphanBuilder::~OrphanBuilder() noexcept(false) {
  if (segment != nullptr) euthanize();
}

inline OrphanBuilder& OrphanBuilder::operator=(OrphanBuilder&& other) {






  if (segment != nullptr) euthanize();
  segment = other.segment;
  capTable = other.capTable;
  location = other.location;
  memcpy(&tag, &other.tag, sizeof(tag));
  other.segment = nullptr;
  other.location = nullptr;
  return *this;
}

}
}
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/list.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/list.h" 3
#define CAPNP_LIST_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/list.h" 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3
#define CAPNP_ORPHAN_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3




namespace capnp {

class StructSchema;
class ListSchema;
struct DynamicStruct;
struct DynamicList;
namespace _ { struct OrphanageInternal; }

template <typename T>
class Orphan {
# 52 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3
public:
  Orphan() = default;
  Orphan(const Orphan&) = delete; Orphan& operator=(const Orphan&) = delete;
  Orphan(Orphan&&) = default;
  Orphan& operator=(Orphan&&) = default;
  inline Orphan(_::OrphanBuilder&& builder): builder(kj::mv(builder)) {}

  inline BuilderFor<T> get();






  inline ReaderFor<T> getReader() const;

  inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }

  inline void truncate(uint size);
# 91 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3
private:
  _::OrphanBuilder builder;

  template <typename, Kind>
  friend struct _::PointerHelpers;
  template <typename, Kind>
  friend struct List;
  template <typename U>
  friend class Orphan;
  friend class Orphanage;
  friend class MessageBuilder;
};

class Orphanage: private kj::DisallowConstCopy {



public:
  inline Orphanage(): arena(nullptr) {}

  template <typename BuilderType>
  static Orphanage getForMessageContaining(BuilderType builder);
# 122 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3
  template <typename RootType>
  Orphan<RootType> newOrphan() const;


  template <typename RootType>
  Orphan<RootType> newOrphan(uint size) const;


  Orphan<DynamicStruct> newOrphan(StructSchema schema) const;



  Orphan<DynamicList> newOrphan(ListSchema schema, uint size) const;



  template <typename Reader>
  Orphan<FromReader<Reader>> newOrphanCopy(Reader copyFrom) const;



  template <typename T>
  Orphan<List<ListElementType<FromReader<T>>>> newOrphanConcat(kj::ArrayPtr<T> lists) const;
  template <typename T>
  Orphan<List<ListElementType<FromReader<T>>>> newOrphanConcat(kj::ArrayPtr<const T> lists) const;
# 156 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3
  Orphan<Data> referenceExternalData(Data::Reader data) const;
# 178 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/orphan.h" 3
private:
  _::BuilderArena* arena;
  _::CapTableBuilder* capTable;

  inline explicit Orphanage(_::BuilderArena* arena, _::CapTableBuilder* capTable)
      : arena(arena), capTable(capTable) {}

  template <typename T, Kind = ::capnp::kind<T>()>
  struct GetInnerBuilder;
  template <typename T, Kind = ::capnp::kind<T>()>
  struct GetInnerReader;
  template <typename T>
  struct NewOrphanListImpl;

  friend class MessageBuilder;
  friend struct _::OrphanageInternal;
};




namespace _ {

template <typename T, Kind = ::capnp::kind<T>()>
struct OrphanGetImpl;

template <typename T>
struct OrphanGetImpl<T, Kind::PRIMITIVE> {
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, _::elementSizeForType<T>());
  }
};

template <typename T>
struct OrphanGetImpl<T, Kind::STRUCT> {
  static inline typename T::Builder apply(_::OrphanBuilder& builder) {
    return typename T::Builder(builder.asStruct(_::structSize<T>()));
  }
  static inline typename T::Reader applyReader(const _::OrphanBuilder& builder) {
    return typename T::Reader(builder.asStructReader(_::structSize<T>()));
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, _::structSize<T>());
  }
};


template <typename T>
struct OrphanGetImpl<T, Kind::INTERFACE> {
  static inline typename T::Client apply(_::OrphanBuilder& builder) {
    return typename T::Client(builder.asCapability());
  }
  static inline typename T::Client applyReader(const _::OrphanBuilder& builder) {
    return typename T::Client(builder.asCapability());
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, ElementSize::POINTER);
  }
};


template <typename T, Kind k>
struct OrphanGetImpl<List<T, k>, Kind::LIST> {
  static inline typename List<T>::Builder apply(_::OrphanBuilder& builder) {
    return typename List<T>::Builder(builder.asList(_::ElementSizeForType<T>::value));
  }
  static inline typename List<T>::Reader applyReader(const _::OrphanBuilder& builder) {
    return typename List<T>::Reader(builder.asListReader(_::ElementSizeForType<T>::value));
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, ElementSize::POINTER);
  }
};

template <typename T>
struct OrphanGetImpl<List<T, Kind::STRUCT>, Kind::LIST> {
  static inline typename List<T>::Builder apply(_::OrphanBuilder& builder) {
    return typename List<T>::Builder(builder.asStructList(_::structSize<T>()));
  }
  static inline typename List<T>::Reader applyReader(const _::OrphanBuilder& builder) {
    return typename List<T>::Reader(builder.asListReader(_::ElementSizeForType<T>::value));
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, ElementSize::POINTER);
  }
};

template <>
struct OrphanGetImpl<Text, Kind::BLOB> {
  static inline Text::Builder apply(_::OrphanBuilder& builder) {
    return Text::Builder(builder.asText());
  }
  static inline Text::Reader applyReader(const _::OrphanBuilder& builder) {
    return Text::Reader(builder.asTextReader());
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, ElementSize::POINTER);
  }
};

template <>
struct OrphanGetImpl<Data, Kind::BLOB> {
  static inline Data::Builder apply(_::OrphanBuilder& builder) {
    return Data::Builder(builder.asData());
  }
  static inline Data::Reader applyReader(const _::OrphanBuilder& builder) {
    return Data::Reader(builder.asDataReader());
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, ElementSize::POINTER);
  }
};

struct OrphanageInternal {
  static inline _::BuilderArena* getArena(Orphanage orphanage) { return orphanage.arena; }
  static inline _::CapTableBuilder* getCapTable(Orphanage orphanage) { return orphanage.capTable; }
};

}

template <typename T>
inline BuilderFor<T> Orphan<T>::get() {
  return _::OrphanGetImpl<T>::apply(builder);
}

template <typename T>
inline ReaderFor<T> Orphan<T>::getReader() const {
  return _::OrphanGetImpl<T>::applyReader(builder);
}

template <typename T>
inline void Orphan<T>::truncate(uint size) {
  _::OrphanGetImpl<ListElementType<T>>::truncateListOf(builder, bounded(size) * ELEMENTS);
}

template <>
inline void Orphan<Text>::truncate(uint size) {
  builder.truncateText(bounded(size) * ELEMENTS);
}

template <>
inline void Orphan<Data>::truncate(uint size) {
  builder.truncate(bounded(size) * ELEMENTS, ElementSize::BYTE);
}

template <typename T>
struct Orphanage::GetInnerBuilder<T, Kind::STRUCT> {
  static inline _::StructBuilder apply(typename T::Builder& t) {
    return t._builder;
  }
};

template <typename T>
struct Orphanage::GetInnerBuilder<T, Kind::LIST> {
  static inline _::ListBuilder apply(typename T::Builder& t) {
    return t.builder;
  }
};

template <typename BuilderType>
Orphanage Orphanage::getForMessageContaining(BuilderType builder) {
  auto inner = GetInnerBuilder<FromBuilder<BuilderType>>::apply(builder);
  return Orphanage(inner.getArena(), inner.getCapTable());
}

template <typename RootType>
Orphan<RootType> Orphanage::newOrphan() const {
  return Orphan<RootType>(_::OrphanBuilder::initStruct(arena, capTable, _::structSize<RootType>()));
}

template <typename T, Kind k>
struct Orphanage::NewOrphanListImpl<List<T, k>> {
  static inline _::OrphanBuilder apply(
      _::BuilderArena* arena, _::CapTableBuilder* capTable, uint size) {
    return _::OrphanBuilder::initList(
        arena, capTable, bounded(size) * ELEMENTS, _::ElementSizeForType<T>::value);
  }
};

template <typename T>
struct Orphanage::NewOrphanListImpl<List<T, Kind::STRUCT>> {
  static inline _::OrphanBuilder apply(
      _::BuilderArena* arena, _::CapTableBuilder* capTable, uint size) {
    return _::OrphanBuilder::initStructList(
        arena, capTable, bounded(size) * ELEMENTS, _::structSize<T>());
  }
};

template <>
struct Orphanage::NewOrphanListImpl<Text> {
  static inline _::OrphanBuilder apply(
      _::BuilderArena* arena, _::CapTableBuilder* capTable, uint size) {
    return _::OrphanBuilder::initText(arena, capTable, bounded(size) * BYTES);
  }
};

template <>
struct Orphanage::NewOrphanListImpl<Data> {
  static inline _::OrphanBuilder apply(
      _::BuilderArena* arena, _::CapTableBuilder* capTable, uint size) {
    return _::OrphanBuilder::initData(arena, capTable, bounded(size) * BYTES);
  }
};

template <typename RootType>
Orphan<RootType> Orphanage::newOrphan(uint size) const {
  return Orphan<RootType>(NewOrphanListImpl<RootType>::apply(arena, capTable, size));
}

template <typename T>
struct Orphanage::GetInnerReader<T, Kind::STRUCT> {
  static inline _::StructReader apply(const typename T::Reader& t) {
    return t._reader;
  }
};

template <typename T>
struct Orphanage::GetInnerReader<T, Kind::LIST> {
  static inline _::ListReader apply(const typename T::Reader& t) {
    return t.reader;
  }
};

template <typename T>
struct Orphanage::GetInnerReader<T, Kind::BLOB> {
  static inline const typename T::Reader& apply(const typename T::Reader& t) {
    return t;
  }
};

template <typename Reader>
inline Orphan<FromReader<Reader>> Orphanage::newOrphanCopy(Reader copyFrom) const {
  return Orphan<FromReader<Reader>>(_::OrphanBuilder::copy(
      arena, capTable, GetInnerReader<FromReader<Reader>>::apply(copyFrom)));
}

template <typename T>
inline Orphan<List<ListElementType<FromReader<T>>>>
Orphanage::newOrphanConcat(kj::ArrayPtr<T> lists) const {
  return newOrphanConcat(kj::implicitCast<kj::ArrayPtr<const T>>(lists));
}
template <typename T>
inline Orphan<List<ListElementType<FromReader<T>>>>
Orphanage::newOrphanConcat(kj::ArrayPtr<const T> lists) const {


  static_assert(sizeof(T) == sizeof(_::ListReader), "lists are not bare readers?");
  kj::ArrayPtr<const _::ListReader> raw(
      reinterpret_cast<const _::ListReader*>(lists.begin()), lists.size());
  typedef ListElementType<FromReader<T>> Element;
  return Orphan<List<Element>>(
      _::OrphanBuilder::concat(arena, capTable,
          _::elementSizeForType<Element>(),
          _::minStructSizeForElement<Element>(), raw));
}

inline Orphan<Data> Orphanage::referenceExternalData(Data::Reader data) const {
  return Orphan<Data>(_::OrphanBuilder::referenceExternalData(arena, data));
}

}
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/list.h" 2 3





namespace capnp {
namespace _ {

template <typename T>
class TemporaryPointer {





public:
  TemporaryPointer(T&& value): value(kj::mv(value)) {}
  TemporaryPointer(const T& value): value(value) {}

  inline T* operator->() { return &value; }
private:
  T value;
};

template <typename Container, typename Element>
class IndexingIterator {
public:
  IndexingIterator() = default;

  inline Element operator*() const { return (*container)[index]; }
  inline TemporaryPointer<Element> operator->() const {
    return TemporaryPointer<Element>((*container)[index]);
  }
  inline Element operator[]( int off) const { return (*container)[index]; }
  inline Element operator[](uint off) const { return (*container)[index]; }

  inline IndexingIterator& operator++() { ++index; return *this; }
  inline IndexingIterator operator++(int) { IndexingIterator other = *this; ++index; return other; }
  inline IndexingIterator& operator--() { --index; return *this; }
  inline IndexingIterator operator--(int) { IndexingIterator other = *this; --index; return other; }

  inline IndexingIterator operator+(uint amount) const { return IndexingIterator(container, index + amount); }
  inline IndexingIterator operator-(uint amount) const { return IndexingIterator(container, index - amount); }
  inline IndexingIterator operator+( int amount) const { return IndexingIterator(container, index + amount); }
  inline IndexingIterator operator-( int amount) const { return IndexingIterator(container, index - amount); }

  inline int operator-(const IndexingIterator& other) const { return index - other.index; }

  inline IndexingIterator& operator+=(uint amount) { index += amount; return *this; }
  inline IndexingIterator& operator-=(uint amount) { index -= amount; return *this; }
  inline IndexingIterator& operator+=( int amount) { index += amount; return *this; }
  inline IndexingIterator& operator-=( int amount) { index -= amount; return *this; }



  inline bool operator==(const IndexingIterator& other) const { return index == other.index; }
  inline bool operator!=(const IndexingIterator& other) const { return index != other.index; }
  inline bool operator<=(const IndexingIterator& other) const { return index <= other.index; }
  inline bool operator>=(const IndexingIterator& other) const { return index >= other.index; }
  inline bool operator< (const IndexingIterator& other) const { return index < other.index; }
  inline bool operator> (const IndexingIterator& other) const { return index > other.index; }

private:
  Container* container;
  uint index;

  friend Container;
  inline IndexingIterator(Container* container, uint index)
      : container(container), index(index) {}
};

}

template <typename T>
struct List<T, Kind::PRIMITIVE> {


  List() = delete;

  class Reader {
  public:
    typedef List<T> Reads;

    inline Reader(): reader(_::elementSizeForType<T>()) {}
    inline explicit Reader(_::ListReader reader): reader(reader) {}

    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
    inline T operator[](uint index) const {
                                 ;
      return reader.template getDataElement<T>(bounded(index) * ELEMENTS);
    }

    typedef _::IndexingIterator<const Reader, T> Iterator;
    inline Iterator begin() const { return Iterator(this, 0); }
    inline Iterator end() const { return Iterator(this, size()); }

  private:
    _::ListReader reader;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    template <typename U, Kind K>
    friend struct List;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Builder {
  public:
    typedef List<T> Builds;

    inline Builder(): builder(_::elementSizeForType<T>()) {}
    inline Builder(decltype(nullptr)): Builder() {}
    inline explicit Builder(_::ListBuilder builder): builder(builder) {}

    inline operator Reader() const { return Reader(builder.asReader()); }
    inline Reader asReader() const { return Reader(builder.asReader()); }

    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
    inline T operator[](uint index) {
                                 ;
      return builder.template getDataElement<T>(bounded(index) * ELEMENTS);
    }
    inline void set(uint index, T value) {






      builder.template setDataElement<T>(bounded(index) * ELEMENTS, value);
    }

    typedef _::IndexingIterator<Builder, T> Iterator;
    inline Iterator begin() { return Iterator(this, 0); }
    inline Iterator end() { return Iterator(this, size()); }

  private:
    _::ListBuilder builder;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Pipeline {};

private:
  inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
    return builder.initList(_::elementSizeForType<T>(), bounded(size) * ELEMENTS);
  }
  inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
    return builder.getList(_::elementSizeForType<T>(), defaultValue);
  }
  inline static _::ListReader getFromPointer(
      const _::PointerReader& reader, const word* defaultValue) {
    return reader.getList(_::elementSizeForType<T>(), defaultValue);
  }

  template <typename U, Kind k>
  friend struct List;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
};

template <typename T>
struct List<T, Kind::ENUM>: public List<T, Kind::PRIMITIVE> {};

template <typename T>
struct List<T, Kind::STRUCT> {


  List() = delete;

  class Reader {
  public:
    typedef List<T> Reads;

    inline Reader(): reader(ElementSize::INLINE_COMPOSITE) {}
    inline explicit Reader(_::ListReader reader): reader(reader) {}

    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
    inline typename T::Reader operator[](uint index) const {
                                 ;
      return typename T::Reader(reader.getStructElement(bounded(index) * ELEMENTS));
    }

    typedef _::IndexingIterator<const Reader, typename T::Reader> Iterator;
    inline Iterator begin() const { return Iterator(this, 0); }
    inline Iterator end() const { return Iterator(this, size()); }

  private:
    _::ListReader reader;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    template <typename U, Kind K>
    friend struct List;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Builder {
  public:
    typedef List<T> Builds;

    inline Builder(): builder(ElementSize::INLINE_COMPOSITE) {}
    inline Builder(decltype(nullptr)): Builder() {}
    inline explicit Builder(_::ListBuilder builder): builder(builder) {}

    inline operator Reader() const { return Reader(builder.asReader()); }
    inline Reader asReader() const { return Reader(builder.asReader()); }

    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
    inline typename T::Builder operator[](uint index) {
                                 ;
      return typename T::Builder(builder.getStructElement(bounded(index) * ELEMENTS));
    }

    inline void adoptWithCaveats(uint index, Orphan<T>&& orphan) {
# 261 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/list.h" 3
                                 ;




      builder.getStructElement(bounded(index) * ELEMENTS).transferContentFrom(
          orphan.builder.asStruct(_::StructSize(ZERO * WORDS, ZERO * POINTERS)));
    }
    inline void setWithCaveats(uint index, const typename T::Reader& reader) {
# 280 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/list.h" 3
                                 ;
      builder.getStructElement(bounded(index) * ELEMENTS).copyContentFrom(reader._reader);
    }






    typedef _::IndexingIterator<Builder, typename T::Builder> Iterator;
    inline Iterator begin() { return Iterator(this, 0); }
    inline Iterator end() { return Iterator(this, size()); }

  private:
    _::ListBuilder builder;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Pipeline {};

private:
  inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
    return builder.initStructList(bounded(size) * ELEMENTS, _::structSize<T>());
  }
  inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
    return builder.getStructList(_::structSize<T>(), defaultValue);
  }
  inline static _::ListReader getFromPointer(
      const _::PointerReader& reader, const word* defaultValue) {
    return reader.getList(ElementSize::INLINE_COMPOSITE, defaultValue);
  }

  template <typename U, Kind k>
  friend struct List;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
};

template <typename T>
struct List<List<T>, Kind::LIST> {


  List() = delete;

  class Reader {
  public:
    typedef List<List<T>> Reads;

    inline Reader(): reader(ElementSize::POINTER) {}
    inline explicit Reader(_::ListReader reader): reader(reader) {}

    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
    inline typename List<T>::Reader operator[](uint index) const {
                                 ;
      return typename List<T>::Reader(_::PointerHelpers<List<T>>::get(
          reader.getPointerElement(bounded(index) * ELEMENTS)));
    }

    typedef _::IndexingIterator<const Reader, typename List<T>::Reader> Iterator;
    inline Iterator begin() const { return Iterator(this, 0); }
    inline Iterator end() const { return Iterator(this, size()); }

  private:
    _::ListReader reader;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    template <typename U, Kind K>
    friend struct List;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Builder {
  public:
    typedef List<List<T>> Builds;

    inline Builder(): builder(ElementSize::POINTER) {}
    inline Builder(decltype(nullptr)): Builder() {}
    inline explicit Builder(_::ListBuilder builder): builder(builder) {}

    inline operator Reader() const { return Reader(builder.asReader()); }
    inline Reader asReader() const { return Reader(builder.asReader()); }

    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
    inline typename List<T>::Builder operator[](uint index) {
                                 ;
      return typename List<T>::Builder(_::PointerHelpers<List<T>>::get(
          builder.getPointerElement(bounded(index) * ELEMENTS)));
    }
    inline typename List<T>::Builder init(uint index, uint size) {
                                       ;
      return typename List<T>::Builder(_::PointerHelpers<List<T>>::init(
          builder.getPointerElement(bounded(index) * ELEMENTS), size));
    }
    inline void set(uint index, typename List<T>::Reader value) {
                                 ;
      builder.getPointerElement(bounded(index) * ELEMENTS).setList(value.reader);
    }
    void set(uint index, std::initializer_list<ReaderFor<T>> value) {
                                 ;
      auto l = init(index, value.size());
      uint i = 0;
      for (auto& element: value) {
        l.set(i++, element);
      }
    }
    inline void adopt(uint index, Orphan<T>&& value) {
                                 ;
      builder.getPointerElement(bounded(index) * ELEMENTS).adopt(kj::mv(value.builder));
    }
    inline Orphan<T> disown(uint index) {
                                 ;
      return Orphan<T>(builder.getPointerElement(bounded(index) * ELEMENTS).disown());
    }

    typedef _::IndexingIterator<Builder, typename List<T>::Builder> Iterator;
    inline Iterator begin() { return Iterator(this, 0); }
    inline Iterator end() { return Iterator(this, size()); }

  private:
    _::ListBuilder builder;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Pipeline {};

private:
  inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
    return builder.initList(ElementSize::POINTER, bounded(size) * ELEMENTS);
  }
  inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
    return builder.getList(ElementSize::POINTER, defaultValue);
  }
  inline static _::ListReader getFromPointer(
      const _::PointerReader& reader, const word* defaultValue) {
    return reader.getList(ElementSize::POINTER, defaultValue);
  }

  template <typename U, Kind k>
  friend struct List;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
};

template <typename T>
struct List<T, Kind::BLOB> {
  List() = delete;

  class Reader {
  public:
    typedef List<T> Reads;

    inline Reader(): reader(ElementSize::POINTER) {}
    inline explicit Reader(_::ListReader reader): reader(reader) {}

    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
    inline typename T::Reader operator[](uint index) const {
                                 ;
      return reader.getPointerElement(bounded(index) * ELEMENTS)
          .template getBlob<T>(nullptr, ZERO * BYTES);
    }

    typedef _::IndexingIterator<const Reader, typename T::Reader> Iterator;
    inline Iterator begin() const { return Iterator(this, 0); }
    inline Iterator end() const { return Iterator(this, size()); }

  private:
    _::ListReader reader;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    template <typename U, Kind K>
    friend struct List;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Builder {
  public:
    typedef List<T> Builds;

    inline Builder(): builder(ElementSize::POINTER) {}
    inline Builder(decltype(nullptr)): Builder() {}
    inline explicit Builder(_::ListBuilder builder): builder(builder) {}

    inline operator Reader() const { return Reader(builder.asReader()); }
    inline Reader asReader() const { return Reader(builder.asReader()); }

    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
    inline typename T::Builder operator[](uint index) {
                                 ;
      return builder.getPointerElement(bounded(index) * ELEMENTS)
          .template getBlob<T>(nullptr, ZERO * BYTES);
    }
    inline void set(uint index, typename T::Reader value) {
                                 ;
      builder.getPointerElement(bounded(index) * ELEMENTS).template setBlob<T>(value);
    }
    inline typename T::Builder init(uint index, uint size) {
                                       ;
      return builder.getPointerElement(bounded(index) * ELEMENTS)
          .template initBlob<T>(bounded(size) * BYTES);
    }
    inline void adopt(uint index, Orphan<T>&& value) {
                                 ;
      builder.getPointerElement(bounded(index) * ELEMENTS).adopt(kj::mv(value.builder));
    }
    inline Orphan<T> disown(uint index) {
                                 ;
      return Orphan<T>(builder.getPointerElement(bounded(index) * ELEMENTS).disown());
    }

    typedef _::IndexingIterator<Builder, typename T::Builder> Iterator;
    inline Iterator begin() { return Iterator(this, 0); }
    inline Iterator end() { return Iterator(this, size()); }

  private:
    _::ListBuilder builder;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Pipeline {};

private:
  inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
    return builder.initList(ElementSize::POINTER, bounded(size) * ELEMENTS);
  }
  inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
    return builder.getList(ElementSize::POINTER, defaultValue);
  }
  inline static _::ListReader getFromPointer(
      const _::PointerReader& reader, const word* defaultValue) {
    return reader.getList(ElementSize::POINTER, defaultValue);
  }

  template <typename U, Kind k>
  friend struct List;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
};

}
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/pointer-helpers.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/pointer-helpers.h" 3
#define CAPNP_POINTER_HELPERS_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/pointer-helpers.h" 3





namespace capnp {
namespace _ {





template <typename T>
struct PointerHelpers<T, Kind::STRUCT> {
  static inline typename T::Reader get(PointerReader reader, const word* defaultValue = nullptr) {
    return typename T::Reader(reader.getStruct(defaultValue));
  }
  static inline typename T::Builder get(PointerBuilder builder,
                                        const word* defaultValue = nullptr) {
    return typename T::Builder(builder.getStruct(structSize<T>(), defaultValue));
  }
  static inline void set(PointerBuilder builder, typename T::Reader value) {
    builder.setStruct(value._reader);
  }
  static inline void setCanonical(PointerBuilder builder, typename T::Reader value) {
    builder.setStruct(value._reader, true);
  }
  static inline typename T::Builder init(PointerBuilder builder) {
    return typename T::Builder(builder.initStruct(structSize<T>()));
  }
  static inline void adopt(PointerBuilder builder, Orphan<T>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<T> disown(PointerBuilder builder) {
    return Orphan<T>(builder.disown());
  }
  static inline _::StructReader getInternalReader(const typename T::Reader& reader) {
    return reader._reader;
  }
  static inline _::StructBuilder getInternalBuilder(typename T::Builder&& builder) {
    return builder._builder;
  }
};

template <typename T>
struct PointerHelpers<List<T>, Kind::LIST> {
  static inline typename List<T>::Reader get(PointerReader reader,
                                             const word* defaultValue = nullptr) {
    return typename List<T>::Reader(List<T>::getFromPointer(reader, defaultValue));
  }
  static inline typename List<T>::Builder get(PointerBuilder builder,
                                              const word* defaultValue = nullptr) {
    return typename List<T>::Builder(List<T>::getFromPointer(builder, defaultValue));
  }
  static inline void set(PointerBuilder builder, typename List<T>::Reader value) {
    builder.setList(value.reader);
  }
  static inline void setCanonical(PointerBuilder builder, typename List<T>::Reader value) {
    builder.setList(value.reader, true);
  }
  static void set(PointerBuilder builder, kj::ArrayPtr<const ReaderFor<T>> value) {
    auto l = init(builder, value.size());
    uint i = 0;
    for (auto& element: value) {
      l.set(i++, element);
    }
  }
  static inline typename List<T>::Builder init(PointerBuilder builder, uint size) {
    return typename List<T>::Builder(List<T>::initPointer(builder, size));
  }
  static inline void adopt(PointerBuilder builder, Orphan<List<T>>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<List<T>> disown(PointerBuilder builder) {
    return Orphan<List<T>>(builder.disown());
  }
  static inline _::ListReader getInternalReader(const typename List<T>::Reader& reader) {
    return reader.reader;
  }
  static inline _::ListBuilder getInternalBuilder(typename List<T>::Builder&& builder) {
    return builder.builder;
  }
};

template <typename T>
struct PointerHelpers<T, Kind::BLOB> {
  static inline typename T::Reader get(PointerReader reader,
                                       const void* defaultValue = nullptr,
                                       uint defaultBytes = 0) {
    return reader.getBlob<T>(defaultValue, bounded(defaultBytes) * BYTES);
  }
  static inline typename T::Builder get(PointerBuilder builder,
                                        const void* defaultValue = nullptr,
                                        uint defaultBytes = 0) {
    return builder.getBlob<T>(defaultValue, bounded(defaultBytes) * BYTES);
  }
  static inline void set(PointerBuilder builder, typename T::Reader value) {
    builder.setBlob<T>(value);
  }
  static inline void setCanonical(PointerBuilder builder, typename T::Reader value) {
    builder.setBlob<T>(value);
  }
  static inline typename T::Builder init(PointerBuilder builder, uint size) {
    return builder.initBlob<T>(bounded(size) * BYTES);
  }
  static inline void adopt(PointerBuilder builder, Orphan<T>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<T> disown(PointerBuilder builder) {
    return Orphan<T>(builder.disown());
  }
};

struct UncheckedMessage {
  typedef const word* Reader;
};

template <> struct Kind_<UncheckedMessage> { static constexpr Kind kind = Kind::OTHER; };

template <>
struct PointerHelpers<UncheckedMessage> {




  static inline const word* get(PointerReader reader) {
    return reader.getUnchecked();
  }
};

}
}
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/any.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/any.h" 3
#define CAPNP_ANY_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/any.h" 3







namespace capnp {

class StructSchema;
class ListSchema;
class InterfaceSchema;
class Orphanage;
class ClientHook;
class PipelineHook;
struct PipelineOp;
struct AnyPointer;

struct AnyList {
  AnyList() = delete;

  class Reader;
  class Builder;
};

struct AnyStruct {
  AnyStruct() = delete;

  class Reader;
  class Builder;
  class Pipeline;
};

template<>
struct List<AnyStruct, Kind::OTHER> {
  List() = delete;

  class Reader;
  class Builder;
};

namespace _ {
template <> struct Kind_<AnyPointer> { static constexpr Kind kind = Kind::OTHER; };
template <> struct Kind_<AnyStruct> { static constexpr Kind kind = Kind::OTHER; };
template <> struct Kind_<AnyList> { static constexpr Kind kind = Kind::OTHER; };
}




enum class Equality {
  NOT_EQUAL,
  EQUAL,
  UNKNOWN_CONTAINS_CAPS
};

kj::StringPtr operator*(::kj::_::Stringifier, Equality res);

struct AnyPointer {



  AnyPointer() = delete;

  class Reader {
  public:
    typedef AnyPointer Reads;

    Reader() = default;
    inline Reader(_::PointerReader reader): reader(reader) {}

    inline MessageSize targetSize() const;


    inline PointerType getPointerType() const;

    inline bool isNull() const { return getPointerType() == PointerType::NULL_; }
    inline bool isStruct() const { return getPointerType() == PointerType::STRUCT; }
    inline bool isList() const { return getPointerType() == PointerType::LIST; }
    inline bool isCapability() const { return getPointerType() == PointerType::CAPABILITY; }

    Equality equals(AnyPointer::Reader right);
    bool operator==(AnyPointer::Reader right);
    inline bool operator!=(AnyPointer::Reader right) {
      return !(*this == right);
    }

    template <typename T>
    inline ReaderFor<T> getAs() const;


    template <typename T>
    inline ReaderFor<T> getAs(StructSchema schema) const;


    template <typename T>
    inline ReaderFor<T> getAs(ListSchema schema) const;


    template <typename T>
    inline ReaderFor<T> getAs(InterfaceSchema schema) const;



    kj::Own<ClientHook> getPipelinedCap(kj::ArrayPtr<const PipelineOp> ops) const;




  private:
    _::PointerReader reader;
    friend struct AnyPointer;
    friend class Orphanage;
    friend class CapReaderContext;
    friend struct _::PointerHelpers<AnyPointer>;
  };

  class Builder {
  public:
    typedef AnyPointer Builds;

    Builder() = delete;
    inline Builder(decltype(nullptr)) {}
    inline Builder(_::PointerBuilder builder): builder(builder) {}

    inline MessageSize targetSize() const;


    inline PointerType getPointerType();

    inline bool isNull() { return getPointerType() == PointerType::NULL_; }
    inline bool isStruct() { return getPointerType() == PointerType::STRUCT; }
    inline bool isList() { return getPointerType() == PointerType::LIST; }
    inline bool isCapability() { return getPointerType() == PointerType::CAPABILITY; }

    inline Equality equals(AnyPointer::Reader right) {
      return asReader().equals(right);
    }
    inline bool operator==(AnyPointer::Reader right) {
      return asReader() == right;
    }
    inline bool operator!=(AnyPointer::Reader right) {
      return !(*this == right);
    }

    inline void clear();


    template <typename T>
    inline BuilderFor<T> getAs();


    template <typename T>
    inline BuilderFor<T> getAs(StructSchema schema);


    template <typename T>
    inline BuilderFor<T> getAs(ListSchema schema);


    template <typename T>
    inline BuilderFor<T> getAs(InterfaceSchema schema);


    template <typename T>
    inline BuilderFor<T> initAs();


    template <typename T>
    inline BuilderFor<T> initAs(uint elementCount);


    template <typename T>
    inline BuilderFor<T> initAs(StructSchema schema);


    template <typename T>
    inline BuilderFor<T> initAs(ListSchema schema, uint elementCount);


    inline AnyList::Builder initAsAnyList(ElementSize elementSize, uint elementCount);


    inline List<AnyStruct>::Builder initAsListOfAnyStruct(
        uint16_t dataWordCount, uint16_t pointerCount, uint elementCount);

    inline AnyStruct::Builder initAsAnyStruct(uint16_t dataWordCount, uint16_t pointerCount);

    template <typename T>
    inline void setAs(ReaderFor<T> value);



    template <typename T>
    inline void setAs(std::initializer_list<ReaderFor<ListElementType<T>>> list);


    template <typename T>
    inline void setCanonicalAs(ReaderFor<T> value);

    inline void set(Reader value) { builder.copyFrom(value.reader); }


    inline void setCanonical(Reader value) { builder.copyFrom(value.reader, true); }

    template <typename T>
    inline void adopt(Orphan<T>&& orphan);



    template <typename T>
    inline Orphan<T> disownAs();


    template <typename T>
    inline Orphan<T> disownAs(StructSchema schema);


    template <typename T>
    inline Orphan<T> disownAs(ListSchema schema);


    template <typename T>
    inline Orphan<T> disownAs(InterfaceSchema schema);


    inline Orphan<AnyPointer> disown();


    inline Reader asReader() const { return Reader(builder.asReader()); }
    inline operator Reader() const { return Reader(builder.asReader()); }

  private:
    _::PointerBuilder builder;
    friend class Orphanage;
    friend class CapBuilderContext;
    friend struct _::PointerHelpers<AnyPointer>;
  };


  class Pipeline {
  public:
    typedef AnyPointer Pipelines;

    inline Pipeline(decltype(nullptr)) {}
    inline explicit Pipeline(kj::Own<PipelineHook>&& hook): hook(kj::mv(hook)) {}

    Pipeline noop();


    Pipeline getPointerField(uint16_t pointerIndex);


    inline AnyStruct::Pipeline asAnyStruct();

    kj::Own<ClientHook> asCap();


    inline kj::Own<PipelineHook> releasePipelineHook() { return kj::mv(hook); }


    template <typename T, typename = kj::EnableIf< ::capnp::kind<FromClient<T> >() == Kind::INTERFACE>>
    inline operator T() { return T(asCap()); }

  private:
    kj::Own<PipelineHook> hook;
    kj::Array<PipelineOp> ops;

    inline Pipeline(kj::Own<PipelineHook>&& hook, kj::Array<PipelineOp>&& ops)
        : hook(kj::mv(hook)), ops(kj::mv(ops)) {}

    friend class LocalClient;
    friend class PipelineHook;
    friend class AnyStruct::Pipeline;
  };

};

template <>
class Orphan<AnyPointer> {


public:
  Orphan() = default;
  Orphan(const Orphan&) = delete; Orphan& operator=(const Orphan&) = delete;
  Orphan(Orphan&&) = default;
  inline Orphan(_::OrphanBuilder&& builder)
      : builder(kj::mv(builder)) {}

  Orphan& operator=(Orphan&&) = default;

  template <typename T>
  inline Orphan(Orphan<T>&& other): builder(kj::mv(other.builder)) {}
  template <typename T>
  inline Orphan& operator=(Orphan<T>&& other) { builder = kj::mv(other.builder); return *this; }






  template <typename T>
  inline BuilderFor<T> getAs();
  template <typename T>
  inline BuilderFor<T> getAs(StructSchema schema);
  template <typename T>
  inline BuilderFor<T> getAs(ListSchema schema);
  template <typename T>
  inline typename T::Client getAs(InterfaceSchema schema);
  template <typename T>
  inline ReaderFor<T> getAsReader() const;
  template <typename T>
  inline ReaderFor<T> getAsReader(StructSchema schema) const;
  template <typename T>
  inline ReaderFor<T> getAsReader(ListSchema schema) const;
  template <typename T>
  inline typename T::Client getAsReader(InterfaceSchema schema) const;

  template <typename T>
  inline Orphan<T> releaseAs();
  template <typename T>
  inline Orphan<T> releaseAs(StructSchema schema);
  template <typename T>
  inline Orphan<T> releaseAs(ListSchema schema);
  template <typename T>
  inline Orphan<T> releaseAs(InterfaceSchema schema);


  inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }

private:
  _::OrphanBuilder builder;

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend class Orphanage;
  template <typename U>
  friend class Orphan;
  friend class AnyPointer::Builder;
};

template <Kind k> struct AnyTypeFor_;
template <> struct AnyTypeFor_<Kind::STRUCT> { typedef AnyStruct Type; };
template <> struct AnyTypeFor_<Kind::LIST> { typedef AnyList Type; };

template <typename T>
using AnyTypeFor = typename AnyTypeFor_< ::capnp::kind<T>()>::Type;

template <typename T>
inline ReaderFor<AnyTypeFor<FromReader<T>>> toAny(T&& value) {
  return ReaderFor<AnyTypeFor<FromReader<T>>>(
      _::PointerHelpers<FromReader<T>>::getInternalReader(value));
}
template <typename T>
inline BuilderFor<AnyTypeFor<FromBuilder<T>>> toAny(T&& value) {
  return BuilderFor<AnyTypeFor<FromBuilder<T>>>(
      _::PointerHelpers<FromBuilder<T>>::getInternalBuilder(kj::mv(value)));
}

template <>
struct List<AnyPointer, Kind::OTHER> {



  List() = delete;

  class Reader {
  public:
    typedef List<AnyPointer> Reads;

    inline Reader(): reader(ElementSize::POINTER) {}
    inline explicit Reader(_::ListReader reader): reader(reader) {}

    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
    inline AnyPointer::Reader operator[](uint index) const {
                                 ;
      return AnyPointer::Reader(reader.getPointerElement(bounded(index) * ELEMENTS));
    }

    typedef _::IndexingIterator<const Reader, typename AnyPointer::Reader> Iterator;
    inline Iterator begin() const { return Iterator(this, 0); }
    inline Iterator end() const { return Iterator(this, size()); }

  private:
    _::ListReader reader;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    template <typename U, Kind K>
    friend struct List;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Builder {
  public:
    typedef List<AnyPointer> Builds;

    Builder() = delete;
    inline Builder(decltype(nullptr)): builder(ElementSize::POINTER) {}
    inline explicit Builder(_::ListBuilder builder): builder(builder) {}

    inline operator Reader() const { return Reader(builder.asReader()); }
    inline Reader asReader() const { return Reader(builder.asReader()); }

    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
    inline AnyPointer::Builder operator[](uint index) {
                                 ;
      return AnyPointer::Builder(builder.getPointerElement(bounded(index) * ELEMENTS));
    }

    typedef _::IndexingIterator<Builder, typename AnyPointer::Builder> Iterator;
    inline Iterator begin() { return Iterator(this, 0); }
    inline Iterator end() { return Iterator(this, size()); }

  private:
    _::ListBuilder builder;
    template <typename, Kind>
    friend struct _::PointerHelpers;
    friend class Orphanage;
    template <typename, Kind>
    friend struct ToDynamic_;
  };
};

class AnyStruct::Reader {
public:
  typedef AnyStruct Reads;

  Reader() = default;
  inline Reader(_::StructReader reader): _reader(reader) {}

  template <typename T, typename = kj::EnableIf< ::capnp::kind<FromReader<T> >() == Kind::STRUCT>>
  inline Reader(T&& value)
      : _reader(_::PointerHelpers<FromReader<T>>::getInternalReader(kj::fwd<T>(value))) {}

  kj::ArrayPtr<const byte> getDataSection() {
    return _reader.getDataSectionAsBlob();
  }
  List<AnyPointer>::Reader getPointerSection() {
    return List<AnyPointer>::Reader(_reader.getPointerSectionAsList());
  }

  kj::Array<word> canonicalize() {
    return _reader.canonicalize();
  }

  Equality equals(AnyStruct::Reader right);
  bool operator==(AnyStruct::Reader right);
  inline bool operator!=(AnyStruct::Reader right) {
    return !(*this == right);
  }

  template <typename T>
  ReaderFor<T> as() const {

    return typename T::Reader(_reader);
  }
private:
  _::StructReader _reader;

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend class Orphanage;
};

class AnyStruct::Builder {
public:
  typedef AnyStruct Builds;

  inline Builder(decltype(nullptr)) {}
  inline Builder(_::StructBuilder builder): _builder(builder) {}


  template <typename T, typename = kj::EnableIf< ::capnp::kind<FromBuilder<T> >() == Kind::STRUCT>>
  inline Builder(T&& value)
      : _builder(_::PointerHelpers<FromBuilder<T>>::getInternalBuilder(kj::fwd<T>(value))) {}


  inline kj::ArrayPtr<byte> getDataSection() {
    return _builder.getDataSectionAsBlob();
  }
  List<AnyPointer>::Builder getPointerSection() {
    return List<AnyPointer>::Builder(_builder.getPointerSectionAsList());
  }

  inline Equality equals(AnyStruct::Reader right) {
    return asReader().equals(right);
  }
  inline bool operator==(AnyStruct::Reader right) {
    return asReader() == right;
  }
  inline bool operator!=(AnyStruct::Reader right) {
    return !(*this == right);
  }

  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return Reader(_builder.asReader()); }

  template <typename T>
  BuilderFor<T> as() {

    return typename T::Builder(_builder);
  }
private:
  _::StructBuilder _builder;
  friend class Orphanage;
  friend class CapBuilderContext;
};


class AnyStruct::Pipeline {
public:
  inline Pipeline(decltype(nullptr)): typeless(nullptr) {}
  inline explicit Pipeline(AnyPointer::Pipeline&& typeless)
      : typeless(kj::mv(typeless)) {}

  inline AnyPointer::Pipeline getPointerField(uint16_t pointerIndex) {





    return typeless.getPointerField(pointerIndex);
  }

private:
  AnyPointer::Pipeline typeless;
};


class List<AnyStruct, Kind::OTHER>::Reader {
public:
  typedef List<AnyStruct> Reads;

  inline Reader(): reader(ElementSize::INLINE_COMPOSITE) {}
  inline explicit Reader(_::ListReader reader): reader(reader) {}

  inline uint size() const { return unbound(reader.size() / ELEMENTS); }
  inline AnyStruct::Reader operator[](uint index) const {
                               ;
    return AnyStruct::Reader(reader.getStructElement(bounded(index) * ELEMENTS));
  }

  typedef _::IndexingIterator<const Reader, typename AnyStruct::Reader> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  _::ListReader reader;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
  template <typename U, Kind K>
  friend struct List;
  friend class Orphanage;
  template <typename U, Kind K>
  friend struct ToDynamic_;
};

class List<AnyStruct, Kind::OTHER>::Builder {
public:
  typedef List<AnyStruct> Builds;

  Builder() = delete;
  inline Builder(decltype(nullptr)): builder(ElementSize::INLINE_COMPOSITE) {}
  inline explicit Builder(_::ListBuilder builder): builder(builder) {}

  inline operator Reader() const { return Reader(builder.asReader()); }
  inline Reader asReader() const { return Reader(builder.asReader()); }

  inline uint size() const { return unbound(builder.size() / ELEMENTS); }
  inline AnyStruct::Builder operator[](uint index) {
                               ;
    return AnyStruct::Builder(builder.getStructElement(bounded(index) * ELEMENTS));
  }

  typedef _::IndexingIterator<Builder, typename AnyStruct::Builder> Iterator;
  inline Iterator begin() { return Iterator(this, 0); }
  inline Iterator end() { return Iterator(this, size()); }

private:
  _::ListBuilder builder;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
  friend class Orphanage;
  template <typename U, Kind K>
  friend struct ToDynamic_;
};

class AnyList::Reader {
public:
  typedef AnyList Reads;

  inline Reader(): _reader(ElementSize::VOID) {}
  inline Reader(_::ListReader reader): _reader(reader) {}


  template <typename T, typename = kj::EnableIf< ::capnp::kind<FromReader<T> >() == Kind::LIST>>
  inline Reader(T&& value)
      : _reader(_::PointerHelpers<FromReader<T>>::getInternalReader(kj::fwd<T>(value))) {}


  inline ElementSize getElementSize() { return _reader.getElementSize(); }
  inline uint size() { return unbound(_reader.size() / ELEMENTS); }

  inline kj::ArrayPtr<const byte> getRawBytes() { return _reader.asRawBytes(); }

  Equality equals(AnyList::Reader right);
  bool operator==(AnyList::Reader right);
  inline bool operator!=(AnyList::Reader right) {
    return !(*this == right);
  }

  template <typename T> ReaderFor<T> as() {

    return ReaderFor<T>(_reader);
  }
private:
  _::ListReader _reader;

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend class Orphanage;
};

class AnyList::Builder {
public:
  typedef AnyList Builds;

  inline Builder(decltype(nullptr)): _builder(ElementSize::VOID) {}
  inline Builder(_::ListBuilder builder): _builder(builder) {}


  template <typename T, typename = kj::EnableIf< ::capnp::kind<FromBuilder<T> >() == Kind::LIST>>
  inline Builder(T&& value)
      : _builder(_::PointerHelpers<FromBuilder<T>>::getInternalBuilder(kj::fwd<T>(value))) {}


  inline ElementSize getElementSize() { return _builder.getElementSize(); }
  inline uint size() { return unbound(_builder.size() / ELEMENTS); }

  Equality equals(AnyList::Reader right);
  inline bool operator==(AnyList::Reader right) {
    return asReader() == right;
  }
  inline bool operator!=(AnyList::Reader right) {
    return !(*this == right);
  }

  template <typename T> BuilderFor<T> as() {

    return BuilderFor<T>(_builder);
  }

  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return Reader(_builder.asReader()); }

private:
  _::ListBuilder _builder;

  friend class Orphanage;
};
# 699 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/any.h" 3
struct PipelineOp {


  enum Type {
    NOOP,

    GET_POINTER_FIELD


  };

  Type type;
  union {
    uint16_t pointerIndex;
  };
};

class PipelineHook {


public:
  virtual kj::Own<PipelineHook> addRef() = 0;


  virtual kj::Own<ClientHook> getPipelinedCap(kj::ArrayPtr<const PipelineOp> ops) = 0;


  virtual kj::Own<ClientHook> getPipelinedCap(kj::Array<PipelineOp>&& ops);



  template <typename Pipeline, typename = FromPipeline<Pipeline>>
  static inline kj::Own<PipelineHook> from(Pipeline&& pipeline);

private:
  template <typename T> struct FromImpl;
};






inline MessageSize AnyPointer::Reader::targetSize() const {
  return reader.targetSize().asPublic();
}

inline PointerType AnyPointer::Reader::getPointerType() const {
  return reader.getPointerType();
}

template <typename T>
inline ReaderFor<T> AnyPointer::Reader::getAs() const {
  return _::PointerHelpers<T>::get(reader);
}

inline MessageSize AnyPointer::Builder::targetSize() const {
  return asReader().targetSize();
}

inline PointerType AnyPointer::Builder::getPointerType() {
  return builder.getPointerType();
}

inline void AnyPointer::Builder::clear() {
  return builder.clear();
}

template <typename T>
inline BuilderFor<T> AnyPointer::Builder::getAs() {
  return _::PointerHelpers<T>::get(builder);
}

template <typename T>
inline BuilderFor<T> AnyPointer::Builder::initAs() {
  return _::PointerHelpers<T>::init(builder);
}

template <typename T>
inline BuilderFor<T> AnyPointer::Builder::initAs(uint elementCount) {
  return _::PointerHelpers<T>::init(builder, elementCount);
}

inline AnyList::Builder AnyPointer::Builder::initAsAnyList(
    ElementSize elementSize, uint elementCount) {
  return AnyList::Builder(builder.initList(elementSize, bounded(elementCount) * ELEMENTS));
}

inline List<AnyStruct>::Builder AnyPointer::Builder::initAsListOfAnyStruct(
    uint16_t dataWordCount, uint16_t pointerCount, uint elementCount) {
  return List<AnyStruct>::Builder(builder.initStructList(bounded(elementCount) * ELEMENTS,
      _::StructSize(bounded(dataWordCount) * WORDS,
                    bounded(pointerCount) * POINTERS)));
}

inline AnyStruct::Builder AnyPointer::Builder::initAsAnyStruct(
    uint16_t dataWordCount, uint16_t pointerCount) {
  return AnyStruct::Builder(builder.initStruct(
      _::StructSize(bounded(dataWordCount) * WORDS,
                    bounded(pointerCount) * POINTERS)));
}

template <typename T>
inline void AnyPointer::Builder::setAs(ReaderFor<T> value) {
  return _::PointerHelpers<T>::set(builder, value);
}

template <typename T>
inline void AnyPointer::Builder::setCanonicalAs(ReaderFor<T> value) {
  return _::PointerHelpers<T>::setCanonical(builder, value);
}

template <typename T>
inline void AnyPointer::Builder::setAs(
    std::initializer_list<ReaderFor<ListElementType<T>>> list) {
  return _::PointerHelpers<T>::set(builder, list);
}

template <typename T>
inline void AnyPointer::Builder::adopt(Orphan<T>&& orphan) {
  _::PointerHelpers<T>::adopt(builder, kj::mv(orphan));
}

template <typename T>
inline Orphan<T> AnyPointer::Builder::disownAs() {
  return _::PointerHelpers<T>::disown(builder);
}

inline Orphan<AnyPointer> AnyPointer::Builder::disown() {
  return Orphan<AnyPointer>(builder.disown());
}

template <> struct ReaderFor_ <AnyPointer, Kind::OTHER> { typedef AnyPointer::Reader Type; };
template <> struct BuilderFor_<AnyPointer, Kind::OTHER> { typedef AnyPointer::Builder Type; };
template <> struct ReaderFor_ <AnyStruct, Kind::OTHER> { typedef AnyStruct::Reader Type; };
template <> struct BuilderFor_<AnyStruct, Kind::OTHER> { typedef AnyStruct::Builder Type; };

template <>
struct Orphanage::GetInnerReader<AnyPointer, Kind::OTHER> {
  static inline _::PointerReader apply(const AnyPointer::Reader& t) {
    return t.reader;
  }
};

template <>
struct Orphanage::GetInnerBuilder<AnyPointer, Kind::OTHER> {
  static inline _::PointerBuilder apply(AnyPointer::Builder& t) {
    return t.builder;
  }
};

template <>
struct Orphanage::GetInnerReader<AnyStruct, Kind::OTHER> {
  static inline _::StructReader apply(const AnyStruct::Reader& t) {
    return t._reader;
  }
};

template <>
struct Orphanage::GetInnerBuilder<AnyStruct, Kind::OTHER> {
  static inline _::StructBuilder apply(AnyStruct::Builder& t) {
    return t._builder;
  }
};

template <>
struct Orphanage::GetInnerReader<AnyList, Kind::OTHER> {
  static inline _::ListReader apply(const AnyList::Reader& t) {
    return t._reader;
  }
};

template <>
struct Orphanage::GetInnerBuilder<AnyList, Kind::OTHER> {
  static inline _::ListBuilder apply(AnyList::Builder& t) {
    return t._builder;
  }
};

template <typename T>
inline BuilderFor<T> Orphan<AnyPointer>::getAs() {
  return _::OrphanGetImpl<T>::apply(builder);
}
template <typename T>
inline ReaderFor<T> Orphan<AnyPointer>::getAsReader() const {
  return _::OrphanGetImpl<T>::applyReader(builder);
}
template <typename T>
inline Orphan<T> Orphan<AnyPointer>::releaseAs() {
  return Orphan<T>(kj::mv(builder));
}



template <>
inline typename AnyPointer::Reader AnyPointer::Reader::getAs<AnyPointer>() const {
  return *this;
}
template <>
inline typename AnyPointer::Builder AnyPointer::Builder::getAs<AnyPointer>() {
  return *this;
}
template <>
inline typename AnyPointer::Builder AnyPointer::Builder::initAs<AnyPointer>() {
  clear();
  return *this;
}
template <>
inline void AnyPointer::Builder::setAs<AnyPointer>(AnyPointer::Reader value) {
  return builder.copyFrom(value.reader);
}
template <>
inline void AnyPointer::Builder::adopt<AnyPointer>(Orphan<AnyPointer>&& orphan) {
  builder.adopt(kj::mv(orphan.builder));
}
template <>
inline Orphan<AnyPointer> AnyPointer::Builder::disownAs<AnyPointer>() {
  return Orphan<AnyPointer>(builder.disown());
}
template <>
inline Orphan<AnyPointer> Orphan<AnyPointer>::releaseAs() {
  return kj::mv(*this);
}

namespace _ {



template <>
struct PointerHelpers<AnyPointer, Kind::OTHER> {
  static inline AnyPointer::Reader get(PointerReader reader,
                                       const void* defaultValue = nullptr,
                                       uint defaultBytes = 0) {
    return AnyPointer::Reader(reader);
  }
  static inline AnyPointer::Builder get(PointerBuilder builder,
                                        const void* defaultValue = nullptr,
                                        uint defaultBytes = 0) {
    return AnyPointer::Builder(builder);
  }
  static inline void set(PointerBuilder builder, AnyPointer::Reader value) {
    AnyPointer::Builder(builder).set(value);
  }
  static inline void adopt(PointerBuilder builder, Orphan<AnyPointer>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<AnyPointer> disown(PointerBuilder builder) {
    return Orphan<AnyPointer>(builder.disown());
  }
  static inline _::PointerReader getInternalReader(const AnyPointer::Reader& reader) {
    return reader.reader;
  }
  static inline _::PointerBuilder getInternalBuilder(AnyPointer::Builder&& builder) {
    return builder.builder;
  }
};

template <>
struct PointerHelpers<AnyStruct, Kind::OTHER> {
  static inline AnyStruct::Reader get(
      PointerReader reader, const word* defaultValue = nullptr) {
    return AnyStruct::Reader(reader.getStruct(defaultValue));
  }
  static inline AnyStruct::Builder get(
      PointerBuilder builder, const word* defaultValue = nullptr) {

    return AnyStruct::Builder(builder.getStruct(
        _::StructSize(ZERO * WORDS, ZERO * POINTERS), defaultValue));
  }
  static inline void set(PointerBuilder builder, AnyStruct::Reader value) {
    builder.setStruct(value._reader);
  }
  static inline AnyStruct::Builder init(
      PointerBuilder builder, uint16_t dataWordCount, uint16_t pointerCount) {
    return AnyStruct::Builder(builder.initStruct(
        StructSize(bounded(dataWordCount) * WORDS,
                   bounded(pointerCount) * POINTERS)));
  }

  static void adopt(PointerBuilder builder, Orphan<AnyStruct>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static Orphan<AnyStruct> disown(PointerBuilder builder) {
    return Orphan<AnyStruct>(builder.disown());
  }
};

template <>
struct PointerHelpers<AnyList, Kind::OTHER> {
  static inline AnyList::Reader get(
      PointerReader reader, const word* defaultValue = nullptr) {
    return AnyList::Reader(reader.getListAnySize(defaultValue));
  }
  static inline AnyList::Builder get(
      PointerBuilder builder, const word* defaultValue = nullptr) {
    return AnyList::Builder(builder.getListAnySize(defaultValue));
  }
  static inline void set(PointerBuilder builder, AnyList::Reader value) {
    builder.setList(value._reader);
  }
  static inline AnyList::Builder init(
      PointerBuilder builder, ElementSize elementSize, uint elementCount) {
    return AnyList::Builder(builder.initList(
        elementSize, bounded(elementCount) * ELEMENTS));
  }
  static inline AnyList::Builder init(
      PointerBuilder builder, uint16_t dataWordCount, uint16_t pointerCount, uint elementCount) {
    return AnyList::Builder(builder.initStructList(
        bounded(elementCount) * ELEMENTS,
        StructSize(bounded(dataWordCount) * WORDS,
                   bounded(pointerCount) * POINTERS)));
  }

  static void adopt(PointerBuilder builder, Orphan<AnyList>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static Orphan<AnyList> disown(PointerBuilder builder) {
    return Orphan<AnyList>(builder.disown());
  }
};

template <>
struct OrphanGetImpl<AnyStruct, Kind::OTHER> {
  static inline AnyStruct::Builder apply(_::OrphanBuilder& builder) {
    return AnyStruct::Builder(builder.asStruct(_::StructSize(ZERO * WORDS, ZERO * POINTERS)));
  }
  static inline AnyStruct::Reader applyReader(const _::OrphanBuilder& builder) {
    return AnyStruct::Reader(builder.asStructReader(_::StructSize(ZERO * WORDS, ZERO * POINTERS)));
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, _::StructSize(ZERO * WORDS, ZERO * POINTERS));
  }
};

template <>
struct OrphanGetImpl<AnyList, Kind::OTHER> {
  static inline AnyList::Builder apply(_::OrphanBuilder& builder) {
    return AnyList::Builder(builder.asListAnySize());
  }
  static inline AnyList::Reader applyReader(const _::OrphanBuilder& builder) {
    return AnyList::Reader(builder.asListReaderAnySize());
  }
  static inline void truncateListOf(_::OrphanBuilder& builder, ElementCount size) {
    builder.truncate(size, ElementSize::POINTER);
  }
};

}



template <typename T>
struct PipelineHook::FromImpl {
  static inline kj::Own<PipelineHook> apply(typename T::Pipeline&& pipeline) {
    return from(kj::mv(pipeline._typeless));
  }
};

template <>
struct PipelineHook::FromImpl<AnyPointer> {
  static inline kj::Own<PipelineHook> apply(AnyPointer::Pipeline&& pipeline) {
    return kj::mv(pipeline.hook);
  }
};

template <typename Pipeline, typename T>
inline kj::Own<PipelineHook> PipelineHook::from(Pipeline&& pipeline) {
  return FromImpl<T>::apply(kj::fwd<Pipeline>(pipeline));
}



}
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string-tree.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string-tree.h" 3
#define KJ_STRING_TREE_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string-tree.h" 3




namespace kj {

class StringTree {
# 47 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/string-tree.h" 3
public:
  inline StringTree(): size_(0) {}
  inline StringTree(String&& text): size_(text.size()), text(kj::mv(text)) {}

  StringTree(Array<StringTree>&& pieces, StringPtr delim);



  inline size_t size() const { return size_; }

  template <typename Func>
  void visit(Func&& func) const;

  String flatten() const;





  void flattenTo(char* __restrict__ target) const;


private:
  size_t size_;
  String text;

  struct Branch;
  Array<Branch> branches;

  inline void fill(char* pos, size_t branchIndex);
  template <typename First, typename... Rest>
  void fill(char* pos, size_t branchIndex, First&& first, Rest&&... rest);
  template <typename... Rest>
  void fill(char* pos, size_t branchIndex, StringTree&& first, Rest&&... rest);
  template <typename... Rest>
  void fill(char* pos, size_t branchIndex, Array<char>&& first, Rest&&... rest);
  template <typename... Rest>
  void fill(char* pos, size_t branchIndex, String&& first, Rest&&... rest);

  template <typename... Params>
  static StringTree concat(Params&&... params);
  static StringTree&& concat(StringTree&& param) { return kj::mv(param); }

  template <typename T>
  static inline size_t flatSize(const T& t) { return t.size(); }
  static inline size_t flatSize(String&& s) { return 0; }
  static inline size_t flatSize(StringTree&& s) { return 0; }

  template <typename T>
  static inline size_t branchCount(const T& t) { return 0; }
  static inline size_t branchCount(String&& s) { return 1; }
  static inline size_t branchCount(StringTree&& s) { return 1; }

  template <typename... Params>
  friend StringTree strTree(Params&&... params);
};

inline StringTree&& operator*(::kj::_::Stringifier, StringTree&& tree) { return kj::mv(tree); }
inline const StringTree& operator*(::kj::_::Stringifier, const StringTree& tree) { return tree; }

inline StringTree operator*(::kj::_::Stringifier, Array<StringTree>&& trees) { return StringTree(kj::mv(trees), ""); }

template <typename... Params>
StringTree strTree(Params&&... params);







namespace _ {

template <typename... Rest>
char* fill(char* __restrict__ target, const StringTree& first, Rest&&... rest) {


  first.flattenTo(target);
  return fill(target + first.size(), kj::fwd<Rest>(rest)...);
}

template <typename T> constexpr bool isStringTree() { return false; }
template <> constexpr bool isStringTree<StringTree>() { return true; }

inline StringTree&& toStringTreeOrCharSequence(StringTree&& tree) { return kj::mv(tree); }
inline StringTree toStringTreeOrCharSequence(String&& str) { return StringTree(kj::mv(str)); }

template <typename T>
inline auto toStringTreeOrCharSequence(T&& value)
    -> decltype(toCharSequence(kj::fwd<T>(value))) {
  static_assert(!isStringTree<Decay<T>>(),
      "When passing a StringTree into kj::strTree(), either pass it by rvalue "
      "(use kj::mv(value)) or explicitly call value.flatten() to make a copy.");

  return toCharSequence(kj::fwd<T>(value));
}

}

struct StringTree::Branch {
  size_t index;


  StringTree content;
};

template <typename Func>
void StringTree::visit(Func&& func) const {
  size_t pos = 0;
  for (auto& branch: branches) {
    if (branch.index > pos) {
      func(text.slice(pos, branch.index));
      pos = branch.index;
    }
    branch.content.visit(func);
  }
  if (text.size() > pos) {
    func(text.slice(pos, text.size()));
  }
}

inline void StringTree::fill(char* pos, size_t branchIndex) {

                                                                                   ;
}

template <typename First, typename... Rest>
void StringTree::fill(char* pos, size_t branchIndex, First&& first, Rest&&... rest) {
  pos = _::fill(pos, kj::fwd<First>(first));
  fill(pos, branchIndex, kj::fwd<Rest>(rest)...);
}

template <typename... Rest>
void StringTree::fill(char* pos, size_t branchIndex, StringTree&& first, Rest&&... rest) {
  branches[branchIndex].index = pos - text.begin();
  branches[branchIndex].content = kj::mv(first);
  fill(pos, branchIndex + 1, kj::fwd<Rest>(rest)...);
}

template <typename... Rest>
void StringTree::fill(char* pos, size_t branchIndex, String&& first, Rest&&... rest) {
  branches[branchIndex].index = pos - text.begin();
  branches[branchIndex].content = StringTree(kj::mv(first));
  fill(pos, branchIndex + 1, kj::fwd<Rest>(rest)...);
}

template <typename... Params>
StringTree StringTree::concat(Params&&... params) {
  StringTree result;
  result.size_ = _::sum({params.size()...});
  result.text = heapString(
      _::sum({StringTree::flatSize(kj::fwd<Params>(params))...}));
  result.branches = heapArray<StringTree::Branch>(
      _::sum({StringTree::branchCount(kj::fwd<Params>(params))...}));
  result.fill(result.text.begin(), 0, kj::fwd<Params>(params)...);
  return result;
}

template <typename... Params>
StringTree strTree(Params&&... params) {
  return StringTree::concat(_::toStringTreeOrCharSequence(kj::fwd<Params>(params))...);
}

}
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 2 3

namespace capnp {

class MessageBuilder;

template <typename T, Kind k = ::capnp::kind<T>()>
struct ToDynamic_;

struct DynamicStruct;

struct Capability;

namespace _ {



template <typename T, typename CapnpPrivate = typename T::_capnpPrivate, bool = false>
inline const RawSchema& rawSchema() {
  return *CapnpPrivate::schema;
}
template <typename T, uint64_t id = schemas::EnumInfo<T>::typeId>
inline const RawSchema& rawSchema() {
  return *schemas::EnumInfo<T>::schema;
}

template <typename T, typename CapnpPrivate = typename T::_capnpPrivate>
inline const RawBrandedSchema& rawBrandedSchema() {
  return *CapnpPrivate::brand();
}
template <typename T, uint64_t id = schemas::EnumInfo<T>::typeId>
inline const RawBrandedSchema& rawBrandedSchema() {
  return schemas::EnumInfo<T>::schema->defaultBrand;
}

template <typename TypeTag, typename... Params>
struct ChooseBrand;



template <typename TypeTag>
struct ChooseBrand<TypeTag> {

  static constexpr _::RawBrandedSchema const* brand() { return &TypeTag::schema->defaultBrand; }
};

template <typename TypeTag, typename... Rest>
struct ChooseBrand<TypeTag, AnyPointer, Rest...>: public ChooseBrand<TypeTag, Rest...> {};


template <typename TypeTag, typename First, typename... Rest>
struct ChooseBrand<TypeTag, First, Rest...> {

  static constexpr _::RawBrandedSchema const* brand() { return &TypeTag::specificBrand; }
};

template <typename T, Kind k = kind<T>()>
struct BrandBindingFor_;

#define HANDLE_TYPE(Type,which) template <> struct BrandBindingFor_<Type, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { which, listDepth, nullptr }; } }






template <> struct BrandBindingFor_<Void, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 0, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<bool, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 1, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<int8_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 2, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<int16_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 3, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<int32_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 4, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<int64_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 5, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<uint8_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 6, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<uint16_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 7, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<uint32_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 8, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<uint64_t, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 9, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<float, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 10, listDepth, nullptr }; } };
template <> struct BrandBindingFor_<double, Kind::PRIMITIVE> { static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) { return { 11, listDepth, nullptr }; } };
#undef HANDLE_TYPE

template <>
struct BrandBindingFor_<Text, Kind::BLOB> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 12, listDepth, nullptr };
  }
};

template <>
struct BrandBindingFor_<Data, Kind::BLOB> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 13, listDepth, nullptr };
  }
};

template <typename T>
struct BrandBindingFor_<List<T>, Kind::LIST> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return BrandBindingFor_<T>::get(listDepth + 1);
  }
};

template <typename T>
struct BrandBindingFor_<T, Kind::ENUM> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 15, listDepth, nullptr };
  }
};

template <typename T>
struct BrandBindingFor_<T, Kind::STRUCT> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 16, listDepth, T::_capnpPrivate::brand() };
  }
};

template <typename T>
struct BrandBindingFor_<T, Kind::INTERFACE> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 17, listDepth, T::_capnpPrivate::brand() };
  }
};

template <>
struct BrandBindingFor_<AnyPointer, Kind::OTHER> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 18, listDepth, 0, 0 };
  }
};

template <>
struct BrandBindingFor_<AnyStruct, Kind::OTHER> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 18, listDepth, 0, 1 };
  }
};

template <>
struct BrandBindingFor_<AnyList, Kind::OTHER> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 18, listDepth, 0, 2 };
  }
};

template <>
struct BrandBindingFor_<Capability, Kind::OTHER> {
  static constexpr RawBrandedSchema::Binding get(uint16_t listDepth) {
    return { 18, listDepth, 0, 3 };
  }
};

template <typename T>
constexpr RawBrandedSchema::Binding brandBindingFor() {
  return BrandBindingFor_<T>::get(0);
}

kj::StringTree structString(StructReader reader, const RawBrandedSchema& schema);
kj::String enumString(uint16_t value, const RawBrandedSchema& schema);



template <typename T>
inline kj::StringTree structString(StructReader reader) {
  return structString(reader, rawBrandedSchema<T>());
}
template <typename T>
inline kj::String enumString(T value) {
  return enumString(static_cast<uint16_t>(value), rawBrandedSchema<T>());
}




template <typename T>
class ConstStruct {
public:
  ConstStruct() = delete;
  ConstStruct(const ConstStruct&) = delete; ConstStruct& operator=(const ConstStruct&) = delete;
  inline explicit constexpr ConstStruct(const word* ptr): ptr(ptr) {}

  inline typename T::Reader get() const {
    return AnyPointer::Reader(PointerReader::getRootUnchecked(ptr)).getAs<T>();
  }

  inline operator typename T::Reader() const { return get(); }
  inline typename T::Reader operator*() const { return get(); }
  inline TemporaryPointer<typename T::Reader> operator->() const { return get(); }

private:
  const word* ptr;
};

template <typename T>
class ConstList {
public:
  ConstList() = delete;
  ConstList(const ConstList&) = delete; ConstList& operator=(const ConstList&) = delete;
  inline explicit constexpr ConstList(const word* ptr): ptr(ptr) {}

  inline typename List<T>::Reader get() const {
    return AnyPointer::Reader(PointerReader::getRootUnchecked(ptr)).getAs<List<T>>();
  }

  inline operator typename List<T>::Reader() const { return get(); }
  inline typename List<T>::Reader operator*() const { return get(); }
  inline TemporaryPointer<typename List<T>::Reader> operator->() const { return get(); }

private:
  const word* ptr;
};

template <size_t size>
class ConstText {
public:
  ConstText() = delete;
  ConstText(const ConstText&) = delete; ConstText& operator=(const ConstText&) = delete;
  inline explicit constexpr ConstText(const word* ptr): ptr(ptr) {}

  inline Text::Reader get() const {
    return Text::Reader(reinterpret_cast<const char*>(ptr), size);
  }

  inline operator Text::Reader() const { return get(); }
  inline Text::Reader operator*() const { return get(); }
  inline TemporaryPointer<Text::Reader> operator->() const { return get(); }

  inline kj::StringPtr toString() const {
    return get();
  }

private:
  const word* ptr;
};

template <size_t size>
inline kj::StringPtr operator*(::kj::_::Stringifier, const ConstText<size>& s) {
  return s.get();
}

template <size_t size>
class ConstData {
public:
  ConstData() = delete;
  ConstData(const ConstData&) = delete; ConstData& operator=(const ConstData&) = delete;
  inline explicit constexpr ConstData(const word* ptr): ptr(ptr) {}

  inline Data::Reader get() const {
    return Data::Reader(reinterpret_cast<const byte*>(ptr), size);
  }

  inline operator Data::Reader() const { return get(); }
  inline Data::Reader operator*() const { return get(); }
  inline TemporaryPointer<Data::Reader> operator->() const { return get(); }

private:
  const word* ptr;
};

template <size_t size>
inline auto operator*(::kj::_::Stringifier, const ConstData<size>& s) -> decltype(kj::toCharSequence(s.get())) {
  return kj::toCharSequence(s.get());
}

}

template <typename T, typename CapnpPrivate = typename T::_capnpPrivate>
inline constexpr uint64_t typeId() { return CapnpPrivate::typeId; }
template <typename T, uint64_t id = schemas::EnumInfo<T>::typeId>
inline constexpr uint64_t typeId() { return id; }



template <typename T>
inline constexpr uint sizeInWords() {



  return unbound((upgradeBound<uint>(_::structSize<T>().data) +
      _::structSize<T>().pointers * WORDS_PER_POINTER) / WORDS);
}

}
# 327 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 3
#define CAPNP_NON_INT_CONSTEXPR_DECL_INIT(value) = value
#define CAPNP_NON_INT_CONSTEXPR_DEF_INIT(value) 







#define CAPNP_AUTO_IF_MSVC(...) __VA_ARGS__
# 371 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 3
#define CAPNP_DECLARE_SCHEMA(id) extern ::capnp::word const* const bp_##id; extern const ::capnp::_::RawSchema s_##id



#define CAPNP_DECLARE_ENUM(type,id) inline ::kj::String KJ_STRINGIFY(type##_##id value) { return ::capnp::_::enumString(value); } template <> struct EnumInfo<type##_##id> { struct IsEnum; static constexpr uint64_t typeId = 0x##id; static inline ::capnp::word const* encodedSchema() { return bp_##id; } static constexpr ::capnp::_::RawSchema const* schema = &s_##id; }
# 385 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 3
#define CAPNP_DEFINE_ENUM(type,id) constexpr uint64_t EnumInfo<type>::typeId; constexpr ::capnp::_::RawSchema const* EnumInfo<type>::schema



#define CAPNP_DECLARE_STRUCT_HEADER(id,dataWordSize_,pointerCount_) struct IsStruct; static constexpr uint64_t typeId = 0x##id; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = dataWordSize_; static constexpr uint16_t pointerCount = pointerCount_; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_##id; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_##id;
# 398 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/generated-header-support.h" 3
#define CAPNP_DECLARE_INTERFACE_HEADER(id) struct IsInterface; static constexpr uint64_t typeId = 0x##id; static constexpr ::capnp::Kind kind = ::capnp::Kind::INTERFACE; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_##id; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_##id;
# 8 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.capnp.h" 2






namespace capnp {
namespace schemas {

extern ::capnp::word const* const bp_e682ab4cf923a417; extern const ::capnp::_::RawSchema s_e682ab4cf923a417;
extern ::capnp::word const* const bp_b9521bccf10fa3b1; extern const ::capnp::_::RawSchema s_b9521bccf10fa3b1;
extern ::capnp::word const* const bp_debf55bbfa0fc242; extern const ::capnp::_::RawSchema s_debf55bbfa0fc242;
extern ::capnp::word const* const bp_9ea0b19b37fb4435; extern const ::capnp::_::RawSchema s_9ea0b19b37fb4435;
extern ::capnp::word const* const bp_b54ab3364333f598; extern const ::capnp::_::RawSchema s_b54ab3364333f598;
extern ::capnp::word const* const bp_e82753cff0c2218f; extern const ::capnp::_::RawSchema s_e82753cff0c2218f;
extern ::capnp::word const* const bp_b18aa5ac7a0d9420; extern const ::capnp::_::RawSchema s_b18aa5ac7a0d9420;
extern ::capnp::word const* const bp_ec1619d4400a0290; extern const ::capnp::_::RawSchema s_ec1619d4400a0290;
extern ::capnp::word const* const bp_9aad50a41f4af45f; extern const ::capnp::_::RawSchema s_9aad50a41f4af45f;
extern ::capnp::word const* const bp_97b14cbe7cfec712; extern const ::capnp::_::RawSchema s_97b14cbe7cfec712;
extern ::capnp::word const* const bp_c42305476bb4746f; extern const ::capnp::_::RawSchema s_c42305476bb4746f;
extern ::capnp::word const* const bp_cafccddb68db1d11; extern const ::capnp::_::RawSchema s_cafccddb68db1d11;
extern ::capnp::word const* const bp_bb90d5c287870be6; extern const ::capnp::_::RawSchema s_bb90d5c287870be6;
extern ::capnp::word const* const bp_978a7cebdc549a4d; extern const ::capnp::_::RawSchema s_978a7cebdc549a4d;
extern ::capnp::word const* const bp_a9962a9ed0a4d7f8; extern const ::capnp::_::RawSchema s_a9962a9ed0a4d7f8;
extern ::capnp::word const* const bp_9500cce23b334d80; extern const ::capnp::_::RawSchema s_9500cce23b334d80;
extern ::capnp::word const* const bp_d07378ede1f9cc60; extern const ::capnp::_::RawSchema s_d07378ede1f9cc60;
extern ::capnp::word const* const bp_87e739250a60ea97; extern const ::capnp::_::RawSchema s_87e739250a60ea97;
extern ::capnp::word const* const bp_9e0e78711a7f87a9; extern const ::capnp::_::RawSchema s_9e0e78711a7f87a9;
extern ::capnp::word const* const bp_ac3a6f60ef4cc6d3; extern const ::capnp::_::RawSchema s_ac3a6f60ef4cc6d3;
extern ::capnp::word const* const bp_ed8bca69f7fb0cbf; extern const ::capnp::_::RawSchema s_ed8bca69f7fb0cbf;
extern ::capnp::word const* const bp_c2573fe8a23e49f1; extern const ::capnp::_::RawSchema s_c2573fe8a23e49f1;
extern ::capnp::word const* const bp_8e3b5f79fe593656; extern const ::capnp::_::RawSchema s_8e3b5f79fe593656;
extern ::capnp::word const* const bp_9dd1f724f4614a85; extern const ::capnp::_::RawSchema s_9dd1f724f4614a85;
extern ::capnp::word const* const bp_baefc9120c56e274; extern const ::capnp::_::RawSchema s_baefc9120c56e274;
extern ::capnp::word const* const bp_903455f06065422b; extern const ::capnp::_::RawSchema s_903455f06065422b;
extern ::capnp::word const* const bp_abd73485a9636bc9; extern const ::capnp::_::RawSchema s_abd73485a9636bc9;
extern ::capnp::word const* const bp_c863cd16969ee7fc; extern const ::capnp::_::RawSchema s_c863cd16969ee7fc;
extern ::capnp::word const* const bp_ce23dcd2d7b00c9b; extern const ::capnp::_::RawSchema s_ce23dcd2d7b00c9b;
extern ::capnp::word const* const bp_f1c8950dab257542; extern const ::capnp::_::RawSchema s_f1c8950dab257542;
extern ::capnp::word const* const bp_d1958f7dba521926; extern const ::capnp::_::RawSchema s_d1958f7dba521926;
enum class ElementSize_d1958f7dba521926: uint16_t {
  EMPTY,
  BIT,
  BYTE,
  TWO_BYTES,
  FOUR_BYTES,
  EIGHT_BYTES,
  POINTER,
  INLINE_COMPOSITE,
};
inline ::kj::String operator*(::kj::_::Stringifier, ElementSize_d1958f7dba521926 value) { return ::capnp::_::enumString(value); } template <> struct EnumInfo<ElementSize_d1958f7dba521926> { struct IsEnum; static constexpr uint64_t typeId = 0xd1958f7dba521926; static inline ::capnp::word const* encodedSchema() { return bp_d1958f7dba521926; } static constexpr ::capnp::_::RawSchema const* schema = &s_d1958f7dba521926; };
extern ::capnp::word const* const bp_d85d305b7d839963; extern const ::capnp::_::RawSchema s_d85d305b7d839963;
extern ::capnp::word const* const bp_bfc546f6210ad7ce; extern const ::capnp::_::RawSchema s_bfc546f6210ad7ce;
extern ::capnp::word const* const bp_cfea0eb02e810062; extern const ::capnp::_::RawSchema s_cfea0eb02e810062;
extern ::capnp::word const* const bp_ae504193122357e5; extern const ::capnp::_::RawSchema s_ae504193122357e5;

}
}

namespace capnp {
namespace schema {

struct Node {
  Node() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    FILE,
    STRUCT,
    ENUM,
    INTERFACE,
    CONST,
    ANNOTATION,
  };
  struct Parameter;
  struct NestedNode;
  struct Struct;
  struct Enum;
  struct Interface;
  struct Const;
  struct Annotation;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xe682ab4cf923a417; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 5; static constexpr uint16_t pointerCount = 6; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_e682ab4cf923a417; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_e682ab4cf923a417;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::Parameter {
  Parameter() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xb9521bccf10fa3b1; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 0; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_b9521bccf10fa3b1; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_b9521bccf10fa3b1;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::NestedNode {
  NestedNode() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xdebf55bbfa0fc242; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_debf55bbfa0fc242; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_debf55bbfa0fc242;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::Struct {
  Struct() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x9ea0b19b37fb4435; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 5; static constexpr uint16_t pointerCount = 6; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_9ea0b19b37fb4435; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_9ea0b19b37fb4435;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::Enum {
  Enum() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xb54ab3364333f598; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 5; static constexpr uint16_t pointerCount = 6; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_b54ab3364333f598; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_b54ab3364333f598;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::Interface {
  Interface() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xe82753cff0c2218f; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 5; static constexpr uint16_t pointerCount = 6; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_e82753cff0c2218f; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_e82753cff0c2218f;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::Const {
  Const() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xb18aa5ac7a0d9420; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 5; static constexpr uint16_t pointerCount = 6; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_b18aa5ac7a0d9420; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_b18aa5ac7a0d9420;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Node::Annotation {
  Annotation() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xec1619d4400a0290; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 5; static constexpr uint16_t pointerCount = 6; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_ec1619d4400a0290; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_ec1619d4400a0290;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Field {
  Field() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    SLOT,
    GROUP,
  };
  static constexpr ::uint16_t NO_DISCRIMINANT = 65535u;
  struct Slot;
  struct Group;
  struct Ordinal;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x9aad50a41f4af45f; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 4; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_9aad50a41f4af45f; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_9aad50a41f4af45f;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Field::Slot {
  Slot() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xc42305476bb4746f; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 4; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_c42305476bb4746f; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_c42305476bb4746f;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Field::Group {
  Group() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xcafccddb68db1d11; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 4; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_cafccddb68db1d11; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_cafccddb68db1d11;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Field::Ordinal {
  Ordinal() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    IMPLICIT,
    EXPLICIT,
  };

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xbb90d5c287870be6; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 4; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_bb90d5c287870be6; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_bb90d5c287870be6;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Enumerant {
  Enumerant() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x978a7cebdc549a4d; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 2; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_978a7cebdc549a4d; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_978a7cebdc549a4d;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Superclass {
  Superclass() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xa9962a9ed0a4d7f8; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_a9962a9ed0a4d7f8; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_a9962a9ed0a4d7f8;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Method {
  Method() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x9500cce23b334d80; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 5; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_9500cce23b334d80; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_9500cce23b334d80;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type {
  Type() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    VOID,
    BOOL,
    INT8,
    INT16,
    INT32,
    INT64,
    UINT8,
    UINT16,
    UINT32,
    UINT64,
    FLOAT32,
    FLOAT64,
    TEXT,
    DATA,
    LIST,
    ENUM,
    STRUCT,
    INTERFACE,
    ANY_POINTER,
  };
  struct List;
  struct Enum;
  struct Struct;
  struct Interface;
  struct AnyPointer;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xd07378ede1f9cc60; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_d07378ede1f9cc60; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_d07378ede1f9cc60;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::List {
  List() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x87e739250a60ea97; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_87e739250a60ea97; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_87e739250a60ea97;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::Enum {
  Enum() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x9e0e78711a7f87a9; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_9e0e78711a7f87a9; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_9e0e78711a7f87a9;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::Struct {
  Struct() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xac3a6f60ef4cc6d3; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_ac3a6f60ef4cc6d3; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_ac3a6f60ef4cc6d3;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::Interface {
  Interface() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xed8bca69f7fb0cbf; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_ed8bca69f7fb0cbf; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_ed8bca69f7fb0cbf;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::AnyPointer {
  AnyPointer() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    UNCONSTRAINED,
    PARAMETER,
    IMPLICIT_METHOD_PARAMETER,
  };
  struct Unconstrained;
  struct Parameter;
  struct ImplicitMethodParameter;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xc2573fe8a23e49f1; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_c2573fe8a23e49f1; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_c2573fe8a23e49f1;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::AnyPointer::Unconstrained {
  Unconstrained() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    ANY_KIND,
    STRUCT,
    LIST,
    CAPABILITY,
  };

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x8e3b5f79fe593656; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_8e3b5f79fe593656; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_8e3b5f79fe593656;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::AnyPointer::Parameter {
  Parameter() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x9dd1f724f4614a85; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_9dd1f724f4614a85; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_9dd1f724f4614a85;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Type::AnyPointer::ImplicitMethodParameter {
  ImplicitMethodParameter() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xbaefc9120c56e274; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 3; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_baefc9120c56e274; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_baefc9120c56e274;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Brand {
  Brand() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Scope;
  struct Binding;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0x903455f06065422b; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 0; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_903455f06065422b; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_903455f06065422b;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Brand::Scope {
  Scope() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    BIND,
    INHERIT,
  };

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xabd73485a9636bc9; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 2; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_abd73485a9636bc9; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_abd73485a9636bc9;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Brand::Binding {
  Binding() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    UNBOUND,
    TYPE,
  };

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xc863cd16969ee7fc; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_c863cd16969ee7fc; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_c863cd16969ee7fc;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Value {
  Value() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  enum Which: uint16_t {
    VOID,
    BOOL,
    INT8,
    INT16,
    INT32,
    INT64,
    UINT8,
    UINT16,
    UINT32,
    UINT64,
    FLOAT32,
    FLOAT64,
    TEXT,
    DATA,
    LIST,
    ENUM,
    STRUCT,
    INTERFACE,
    ANY_POINTER,
  };

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xce23dcd2d7b00c9b; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 2; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_ce23dcd2d7b00c9b; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_ce23dcd2d7b00c9b;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct Annotation {
  Annotation() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xf1c8950dab257542; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 2; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_f1c8950dab257542; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_f1c8950dab257542;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

typedef ::capnp::schemas::ElementSize_d1958f7dba521926 ElementSize;

struct CapnpVersion {
  CapnpVersion() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xd85d305b7d839963; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 0; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_d85d305b7d839963; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_d85d305b7d839963;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct CodeGeneratorRequest {
  CodeGeneratorRequest() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct RequestedFile;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xbfc546f6210ad7ce; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 0; static constexpr uint16_t pointerCount = 3; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_bfc546f6210ad7ce; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_bfc546f6210ad7ce;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct CodeGeneratorRequest::RequestedFile {
  RequestedFile() = delete;

  class Reader;
  class Builder;
  class Pipeline;
  struct Import;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xcfea0eb02e810062; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 2; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_cfea0eb02e810062; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_cfea0eb02e810062;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};

struct CodeGeneratorRequest::RequestedFile::Import {
  Import() = delete;

  class Reader;
  class Builder;
  class Pipeline;

  struct _capnpPrivate {
    struct IsStruct; static constexpr uint64_t typeId = 0xae504193122357e5; static constexpr ::capnp::Kind kind = ::capnp::Kind::STRUCT; static constexpr uint16_t dataWordSize = 1; static constexpr uint16_t pointerCount = 1; static inline ::capnp::word const* encodedSchema() { return ::capnp::schemas::bp_ae504193122357e5; } static constexpr ::capnp::_::RawSchema const* schema = &::capnp::schemas::s_ae504193122357e5;

    static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }

  };
};



class Node::Reader {
public:
  typedef Node Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline ::uint64_t getId() const;

  inline bool hasDisplayName() const;
  inline ::capnp::Text::Reader getDisplayName() const;

  inline ::uint32_t getDisplayNamePrefixLength() const;

  inline ::uint64_t getScopeId() const;

  inline bool hasNestedNodes() const;
  inline ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader getNestedNodes() const;

  inline bool hasAnnotations() const;
  inline ::capnp::List< ::capnp::schema::Annotation>::Reader getAnnotations() const;

  inline bool isFile() const;
  inline ::capnp::Void getFile() const;

  inline bool isStruct() const;
  inline typename Struct::Reader getStruct() const;

  inline bool isEnum() const;
  inline typename Enum::Reader getEnum() const;

  inline bool isInterface() const;
  inline typename Interface::Reader getInterface() const;

  inline bool isConst() const;
  inline typename Const::Reader getConst() const;

  inline bool isAnnotation() const;
  inline typename Annotation::Reader getAnnotation() const;

  inline bool hasParameters() const;
  inline ::capnp::List< ::capnp::schema::Node::Parameter>::Reader getParameters() const;

  inline bool getIsGeneric() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Builder {
public:
  typedef Node Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline ::uint64_t getId();
  inline void setId( ::uint64_t value);

  inline bool hasDisplayName();
  inline ::capnp::Text::Builder getDisplayName();
  inline void setDisplayName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initDisplayName(unsigned int size);
  inline void adoptDisplayName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownDisplayName();

  inline ::uint32_t getDisplayNamePrefixLength();
  inline void setDisplayNamePrefixLength( ::uint32_t value);

  inline ::uint64_t getScopeId();
  inline void setScopeId( ::uint64_t value);

  inline bool hasNestedNodes();
  inline ::capnp::List< ::capnp::schema::Node::NestedNode>::Builder getNestedNodes();
  inline void setNestedNodes( ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader value);
  inline ::capnp::List< ::capnp::schema::Node::NestedNode>::Builder initNestedNodes(unsigned int size);
  inline void adoptNestedNodes(::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::NestedNode>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::NestedNode>> disownNestedNodes();

  inline bool hasAnnotations();
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder getAnnotations();
  inline void setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value);
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder initAnnotations(unsigned int size);
  inline void adoptAnnotations(::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> disownAnnotations();

  inline bool isFile();
  inline ::capnp::Void getFile();
  inline void setFile( ::capnp::Void value = ::capnp::VOID);

  inline bool isStruct();
  inline typename Struct::Builder getStruct();
  inline typename Struct::Builder initStruct();

  inline bool isEnum();
  inline typename Enum::Builder getEnum();
  inline typename Enum::Builder initEnum();

  inline bool isInterface();
  inline typename Interface::Builder getInterface();
  inline typename Interface::Builder initInterface();

  inline bool isConst();
  inline typename Const::Builder getConst();
  inline typename Const::Builder initConst();

  inline bool isAnnotation();
  inline typename Annotation::Builder getAnnotation();
  inline typename Annotation::Builder initAnnotation();

  inline bool hasParameters();
  inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder getParameters();
  inline void setParameters( ::capnp::List< ::capnp::schema::Node::Parameter>::Reader value);
  inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder initParameters(unsigned int size);
  inline void adoptParameters(::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>> disownParameters();

  inline bool getIsGeneric();
  inline void setIsGeneric(bool value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Pipeline {
public:
  typedef Node Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::Parameter::Reader {
public:
  typedef Parameter Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasName() const;
  inline ::capnp::Text::Reader getName() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Parameter::Builder {
public:
  typedef Parameter Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasName();
  inline ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Parameter::Pipeline {
public:
  typedef Parameter Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::NestedNode::Reader {
public:
  typedef NestedNode Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasName() const;
  inline ::capnp::Text::Reader getName() const;

  inline ::uint64_t getId() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::NestedNode::Builder {
public:
  typedef NestedNode Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasName();
  inline ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

  inline ::uint64_t getId();
  inline void setId( ::uint64_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::NestedNode::Pipeline {
public:
  typedef NestedNode Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::Struct::Reader {
public:
  typedef Struct Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint16_t getDataWordCount() const;

  inline ::uint16_t getPointerCount() const;

  inline ::capnp::schema::ElementSize getPreferredListEncoding() const;

  inline bool getIsGroup() const;

  inline ::uint16_t getDiscriminantCount() const;

  inline ::uint32_t getDiscriminantOffset() const;

  inline bool hasFields() const;
  inline ::capnp::List< ::capnp::schema::Field>::Reader getFields() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Struct::Builder {
public:
  typedef Struct Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint16_t getDataWordCount();
  inline void setDataWordCount( ::uint16_t value);

  inline ::uint16_t getPointerCount();
  inline void setPointerCount( ::uint16_t value);

  inline ::capnp::schema::ElementSize getPreferredListEncoding();
  inline void setPreferredListEncoding( ::capnp::schema::ElementSize value);

  inline bool getIsGroup();
  inline void setIsGroup(bool value);

  inline ::uint16_t getDiscriminantCount();
  inline void setDiscriminantCount( ::uint16_t value);

  inline ::uint32_t getDiscriminantOffset();
  inline void setDiscriminantOffset( ::uint32_t value);

  inline bool hasFields();
  inline ::capnp::List< ::capnp::schema::Field>::Builder getFields();
  inline void setFields( ::capnp::List< ::capnp::schema::Field>::Reader value);
  inline ::capnp::List< ::capnp::schema::Field>::Builder initFields(unsigned int size);
  inline void adoptFields(::capnp::Orphan< ::capnp::List< ::capnp::schema::Field>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Field>> disownFields();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Struct::Pipeline {
public:
  typedef Struct Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::Enum::Reader {
public:
  typedef Enum Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasEnumerants() const;
  inline ::capnp::List< ::capnp::schema::Enumerant>::Reader getEnumerants() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Enum::Builder {
public:
  typedef Enum Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasEnumerants();
  inline ::capnp::List< ::capnp::schema::Enumerant>::Builder getEnumerants();
  inline void setEnumerants( ::capnp::List< ::capnp::schema::Enumerant>::Reader value);
  inline ::capnp::List< ::capnp::schema::Enumerant>::Builder initEnumerants(unsigned int size);
  inline void adoptEnumerants(::capnp::Orphan< ::capnp::List< ::capnp::schema::Enumerant>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Enumerant>> disownEnumerants();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Enum::Pipeline {
public:
  typedef Enum Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::Interface::Reader {
public:
  typedef Interface Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasMethods() const;
  inline ::capnp::List< ::capnp::schema::Method>::Reader getMethods() const;

  inline bool hasSuperclasses() const;
  inline ::capnp::List< ::capnp::schema::Superclass>::Reader getSuperclasses() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Interface::Builder {
public:
  typedef Interface Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasMethods();
  inline ::capnp::List< ::capnp::schema::Method>::Builder getMethods();
  inline void setMethods( ::capnp::List< ::capnp::schema::Method>::Reader value);
  inline ::capnp::List< ::capnp::schema::Method>::Builder initMethods(unsigned int size);
  inline void adoptMethods(::capnp::Orphan< ::capnp::List< ::capnp::schema::Method>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Method>> disownMethods();

  inline bool hasSuperclasses();
  inline ::capnp::List< ::capnp::schema::Superclass>::Builder getSuperclasses();
  inline void setSuperclasses( ::capnp::List< ::capnp::schema::Superclass>::Reader value);
  inline ::capnp::List< ::capnp::schema::Superclass>::Builder initSuperclasses(unsigned int size);
  inline void adoptSuperclasses(::capnp::Orphan< ::capnp::List< ::capnp::schema::Superclass>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Superclass>> disownSuperclasses();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Interface::Pipeline {
public:
  typedef Interface Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::Const::Reader {
public:
  typedef Const Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasType() const;
  inline ::capnp::schema::Type::Reader getType() const;

  inline bool hasValue() const;
  inline ::capnp::schema::Value::Reader getValue() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Const::Builder {
public:
  typedef Const Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasType();
  inline ::capnp::schema::Type::Builder getType();
  inline void setType( ::capnp::schema::Type::Reader value);
  inline ::capnp::schema::Type::Builder initType();
  inline void adoptType(::capnp::Orphan< ::capnp::schema::Type>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Type> disownType();

  inline bool hasValue();
  inline ::capnp::schema::Value::Builder getValue();
  inline void setValue( ::capnp::schema::Value::Reader value);
  inline ::capnp::schema::Value::Builder initValue();
  inline void adoptValue(::capnp::Orphan< ::capnp::schema::Value>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Value> disownValue();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Const::Pipeline {
public:
  typedef Const Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Type::Pipeline getType();
  inline ::capnp::schema::Value::Pipeline getValue();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Node::Annotation::Reader {
public:
  typedef Annotation Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasType() const;
  inline ::capnp::schema::Type::Reader getType() const;

  inline bool getTargetsFile() const;

  inline bool getTargetsConst() const;

  inline bool getTargetsEnum() const;

  inline bool getTargetsEnumerant() const;

  inline bool getTargetsStruct() const;

  inline bool getTargetsField() const;

  inline bool getTargetsUnion() const;

  inline bool getTargetsGroup() const;

  inline bool getTargetsInterface() const;

  inline bool getTargetsMethod() const;

  inline bool getTargetsParam() const;

  inline bool getTargetsAnnotation() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Node::Annotation::Builder {
public:
  typedef Annotation Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasType();
  inline ::capnp::schema::Type::Builder getType();
  inline void setType( ::capnp::schema::Type::Reader value);
  inline ::capnp::schema::Type::Builder initType();
  inline void adoptType(::capnp::Orphan< ::capnp::schema::Type>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Type> disownType();

  inline bool getTargetsFile();
  inline void setTargetsFile(bool value);

  inline bool getTargetsConst();
  inline void setTargetsConst(bool value);

  inline bool getTargetsEnum();
  inline void setTargetsEnum(bool value);

  inline bool getTargetsEnumerant();
  inline void setTargetsEnumerant(bool value);

  inline bool getTargetsStruct();
  inline void setTargetsStruct(bool value);

  inline bool getTargetsField();
  inline void setTargetsField(bool value);

  inline bool getTargetsUnion();
  inline void setTargetsUnion(bool value);

  inline bool getTargetsGroup();
  inline void setTargetsGroup(bool value);

  inline bool getTargetsInterface();
  inline void setTargetsInterface(bool value);

  inline bool getTargetsMethod();
  inline void setTargetsMethod(bool value);

  inline bool getTargetsParam();
  inline void setTargetsParam(bool value);

  inline bool getTargetsAnnotation();
  inline void setTargetsAnnotation(bool value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Node::Annotation::Pipeline {
public:
  typedef Annotation Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Type::Pipeline getType();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Field::Reader {
public:
  typedef Field Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool hasName() const;
  inline ::capnp::Text::Reader getName() const;

  inline ::uint16_t getCodeOrder() const;

  inline bool hasAnnotations() const;
  inline ::capnp::List< ::capnp::schema::Annotation>::Reader getAnnotations() const;

  inline ::uint16_t getDiscriminantValue() const;

  inline bool isSlot() const;
  inline typename Slot::Reader getSlot() const;

  inline bool isGroup() const;
  inline typename Group::Reader getGroup() const;

  inline typename Ordinal::Reader getOrdinal() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Field::Builder {
public:
  typedef Field Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool hasName();
  inline ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

  inline ::uint16_t getCodeOrder();
  inline void setCodeOrder( ::uint16_t value);

  inline bool hasAnnotations();
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder getAnnotations();
  inline void setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value);
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder initAnnotations(unsigned int size);
  inline void adoptAnnotations(::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> disownAnnotations();

  inline ::uint16_t getDiscriminantValue();
  inline void setDiscriminantValue( ::uint16_t value);

  inline bool isSlot();
  inline typename Slot::Builder getSlot();
  inline typename Slot::Builder initSlot();

  inline bool isGroup();
  inline typename Group::Builder getGroup();
  inline typename Group::Builder initGroup();

  inline typename Ordinal::Builder getOrdinal();
  inline typename Ordinal::Builder initOrdinal();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Field::Pipeline {
public:
  typedef Field Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline typename Ordinal::Pipeline getOrdinal();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Field::Slot::Reader {
public:
  typedef Slot Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint32_t getOffset() const;

  inline bool hasType() const;
  inline ::capnp::schema::Type::Reader getType() const;

  inline bool hasDefaultValue() const;
  inline ::capnp::schema::Value::Reader getDefaultValue() const;

  inline bool getHadExplicitDefault() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Field::Slot::Builder {
public:
  typedef Slot Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint32_t getOffset();
  inline void setOffset( ::uint32_t value);

  inline bool hasType();
  inline ::capnp::schema::Type::Builder getType();
  inline void setType( ::capnp::schema::Type::Reader value);
  inline ::capnp::schema::Type::Builder initType();
  inline void adoptType(::capnp::Orphan< ::capnp::schema::Type>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Type> disownType();

  inline bool hasDefaultValue();
  inline ::capnp::schema::Value::Builder getDefaultValue();
  inline void setDefaultValue( ::capnp::schema::Value::Reader value);
  inline ::capnp::schema::Value::Builder initDefaultValue();
  inline void adoptDefaultValue(::capnp::Orphan< ::capnp::schema::Value>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Value> disownDefaultValue();

  inline bool getHadExplicitDefault();
  inline void setHadExplicitDefault(bool value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Field::Slot::Pipeline {
public:
  typedef Slot Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Type::Pipeline getType();
  inline ::capnp::schema::Value::Pipeline getDefaultValue();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Field::Group::Reader {
public:
  typedef Group Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getTypeId() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Field::Group::Builder {
public:
  typedef Group Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getTypeId();
  inline void setTypeId( ::uint64_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Field::Group::Pipeline {
public:
  typedef Group Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Field::Ordinal::Reader {
public:
  typedef Ordinal Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool isImplicit() const;
  inline ::capnp::Void getImplicit() const;

  inline bool isExplicit() const;
  inline ::uint16_t getExplicit() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Field::Ordinal::Builder {
public:
  typedef Ordinal Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool isImplicit();
  inline ::capnp::Void getImplicit();
  inline void setImplicit( ::capnp::Void value = ::capnp::VOID);

  inline bool isExplicit();
  inline ::uint16_t getExplicit();
  inline void setExplicit( ::uint16_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Field::Ordinal::Pipeline {
public:
  typedef Ordinal Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Enumerant::Reader {
public:
  typedef Enumerant Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasName() const;
  inline ::capnp::Text::Reader getName() const;

  inline ::uint16_t getCodeOrder() const;

  inline bool hasAnnotations() const;
  inline ::capnp::List< ::capnp::schema::Annotation>::Reader getAnnotations() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Enumerant::Builder {
public:
  typedef Enumerant Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasName();
  inline ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

  inline ::uint16_t getCodeOrder();
  inline void setCodeOrder( ::uint16_t value);

  inline bool hasAnnotations();
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder getAnnotations();
  inline void setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value);
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder initAnnotations(unsigned int size);
  inline void adoptAnnotations(::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> disownAnnotations();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Enumerant::Pipeline {
public:
  typedef Enumerant Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Superclass::Reader {
public:
  typedef Superclass Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getId() const;

  inline bool hasBrand() const;
  inline ::capnp::schema::Brand::Reader getBrand() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Superclass::Builder {
public:
  typedef Superclass Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getId();
  inline void setId( ::uint64_t value);

  inline bool hasBrand();
  inline ::capnp::schema::Brand::Builder getBrand();
  inline void setBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initBrand();
  inline void adoptBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownBrand();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Superclass::Pipeline {
public:
  typedef Superclass Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Brand::Pipeline getBrand();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Method::Reader {
public:
  typedef Method Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasName() const;
  inline ::capnp::Text::Reader getName() const;

  inline ::uint16_t getCodeOrder() const;

  inline ::uint64_t getParamStructType() const;

  inline ::uint64_t getResultStructType() const;

  inline bool hasAnnotations() const;
  inline ::capnp::List< ::capnp::schema::Annotation>::Reader getAnnotations() const;

  inline bool hasParamBrand() const;
  inline ::capnp::schema::Brand::Reader getParamBrand() const;

  inline bool hasResultBrand() const;
  inline ::capnp::schema::Brand::Reader getResultBrand() const;

  inline bool hasImplicitParameters() const;
  inline ::capnp::List< ::capnp::schema::Node::Parameter>::Reader getImplicitParameters() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Method::Builder {
public:
  typedef Method Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasName();
  inline ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

  inline ::uint16_t getCodeOrder();
  inline void setCodeOrder( ::uint16_t value);

  inline ::uint64_t getParamStructType();
  inline void setParamStructType( ::uint64_t value);

  inline ::uint64_t getResultStructType();
  inline void setResultStructType( ::uint64_t value);

  inline bool hasAnnotations();
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder getAnnotations();
  inline void setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value);
  inline ::capnp::List< ::capnp::schema::Annotation>::Builder initAnnotations(unsigned int size);
  inline void adoptAnnotations(::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> disownAnnotations();

  inline bool hasParamBrand();
  inline ::capnp::schema::Brand::Builder getParamBrand();
  inline void setParamBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initParamBrand();
  inline void adoptParamBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownParamBrand();

  inline bool hasResultBrand();
  inline ::capnp::schema::Brand::Builder getResultBrand();
  inline void setResultBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initResultBrand();
  inline void adoptResultBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownResultBrand();

  inline bool hasImplicitParameters();
  inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder getImplicitParameters();
  inline void setImplicitParameters( ::capnp::List< ::capnp::schema::Node::Parameter>::Reader value);
  inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder initImplicitParameters(unsigned int size);
  inline void adoptImplicitParameters(::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>> disownImplicitParameters();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Method::Pipeline {
public:
  typedef Method Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Brand::Pipeline getParamBrand();
  inline ::capnp::schema::Brand::Pipeline getResultBrand();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::Reader {
public:
  typedef Type Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool isVoid() const;
  inline ::capnp::Void getVoid() const;

  inline bool isBool() const;
  inline ::capnp::Void getBool() const;

  inline bool isInt8() const;
  inline ::capnp::Void getInt8() const;

  inline bool isInt16() const;
  inline ::capnp::Void getInt16() const;

  inline bool isInt32() const;
  inline ::capnp::Void getInt32() const;

  inline bool isInt64() const;
  inline ::capnp::Void getInt64() const;

  inline bool isUint8() const;
  inline ::capnp::Void getUint8() const;

  inline bool isUint16() const;
  inline ::capnp::Void getUint16() const;

  inline bool isUint32() const;
  inline ::capnp::Void getUint32() const;

  inline bool isUint64() const;
  inline ::capnp::Void getUint64() const;

  inline bool isFloat32() const;
  inline ::capnp::Void getFloat32() const;

  inline bool isFloat64() const;
  inline ::capnp::Void getFloat64() const;

  inline bool isText() const;
  inline ::capnp::Void getText() const;

  inline bool isData() const;
  inline ::capnp::Void getData() const;

  inline bool isList() const;
  inline typename List::Reader getList() const;

  inline bool isEnum() const;
  inline typename Enum::Reader getEnum() const;

  inline bool isStruct() const;
  inline typename Struct::Reader getStruct() const;

  inline bool isInterface() const;
  inline typename Interface::Reader getInterface() const;

  inline bool isAnyPointer() const;
  inline typename AnyPointer::Reader getAnyPointer() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::Builder {
public:
  typedef Type Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool isVoid();
  inline ::capnp::Void getVoid();
  inline void setVoid( ::capnp::Void value = ::capnp::VOID);

  inline bool isBool();
  inline ::capnp::Void getBool();
  inline void setBool( ::capnp::Void value = ::capnp::VOID);

  inline bool isInt8();
  inline ::capnp::Void getInt8();
  inline void setInt8( ::capnp::Void value = ::capnp::VOID);

  inline bool isInt16();
  inline ::capnp::Void getInt16();
  inline void setInt16( ::capnp::Void value = ::capnp::VOID);

  inline bool isInt32();
  inline ::capnp::Void getInt32();
  inline void setInt32( ::capnp::Void value = ::capnp::VOID);

  inline bool isInt64();
  inline ::capnp::Void getInt64();
  inline void setInt64( ::capnp::Void value = ::capnp::VOID);

  inline bool isUint8();
  inline ::capnp::Void getUint8();
  inline void setUint8( ::capnp::Void value = ::capnp::VOID);

  inline bool isUint16();
  inline ::capnp::Void getUint16();
  inline void setUint16( ::capnp::Void value = ::capnp::VOID);

  inline bool isUint32();
  inline ::capnp::Void getUint32();
  inline void setUint32( ::capnp::Void value = ::capnp::VOID);

  inline bool isUint64();
  inline ::capnp::Void getUint64();
  inline void setUint64( ::capnp::Void value = ::capnp::VOID);

  inline bool isFloat32();
  inline ::capnp::Void getFloat32();
  inline void setFloat32( ::capnp::Void value = ::capnp::VOID);

  inline bool isFloat64();
  inline ::capnp::Void getFloat64();
  inline void setFloat64( ::capnp::Void value = ::capnp::VOID);

  inline bool isText();
  inline ::capnp::Void getText();
  inline void setText( ::capnp::Void value = ::capnp::VOID);

  inline bool isData();
  inline ::capnp::Void getData();
  inline void setData( ::capnp::Void value = ::capnp::VOID);

  inline bool isList();
  inline typename List::Builder getList();
  inline typename List::Builder initList();

  inline bool isEnum();
  inline typename Enum::Builder getEnum();
  inline typename Enum::Builder initEnum();

  inline bool isStruct();
  inline typename Struct::Builder getStruct();
  inline typename Struct::Builder initStruct();

  inline bool isInterface();
  inline typename Interface::Builder getInterface();
  inline typename Interface::Builder initInterface();

  inline bool isAnyPointer();
  inline typename AnyPointer::Builder getAnyPointer();
  inline typename AnyPointer::Builder initAnyPointer();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::Pipeline {
public:
  typedef Type Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::List::Reader {
public:
  typedef List Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasElementType() const;
  inline ::capnp::schema::Type::Reader getElementType() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::List::Builder {
public:
  typedef List Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasElementType();
  inline ::capnp::schema::Type::Builder getElementType();
  inline void setElementType( ::capnp::schema::Type::Reader value);
  inline ::capnp::schema::Type::Builder initElementType();
  inline void adoptElementType(::capnp::Orphan< ::capnp::schema::Type>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Type> disownElementType();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::List::Pipeline {
public:
  typedef List Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Type::Pipeline getElementType();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::Enum::Reader {
public:
  typedef Enum Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getTypeId() const;

  inline bool hasBrand() const;
  inline ::capnp::schema::Brand::Reader getBrand() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::Enum::Builder {
public:
  typedef Enum Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getTypeId();
  inline void setTypeId( ::uint64_t value);

  inline bool hasBrand();
  inline ::capnp::schema::Brand::Builder getBrand();
  inline void setBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initBrand();
  inline void adoptBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownBrand();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::Enum::Pipeline {
public:
  typedef Enum Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Brand::Pipeline getBrand();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::Struct::Reader {
public:
  typedef Struct Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getTypeId() const;

  inline bool hasBrand() const;
  inline ::capnp::schema::Brand::Reader getBrand() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::Struct::Builder {
public:
  typedef Struct Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getTypeId();
  inline void setTypeId( ::uint64_t value);

  inline bool hasBrand();
  inline ::capnp::schema::Brand::Builder getBrand();
  inline void setBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initBrand();
  inline void adoptBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownBrand();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::Struct::Pipeline {
public:
  typedef Struct Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Brand::Pipeline getBrand();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::Interface::Reader {
public:
  typedef Interface Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getTypeId() const;

  inline bool hasBrand() const;
  inline ::capnp::schema::Brand::Reader getBrand() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::Interface::Builder {
public:
  typedef Interface Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getTypeId();
  inline void setTypeId( ::uint64_t value);

  inline bool hasBrand();
  inline ::capnp::schema::Brand::Builder getBrand();
  inline void setBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initBrand();
  inline void adoptBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownBrand();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::Interface::Pipeline {
public:
  typedef Interface Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Brand::Pipeline getBrand();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::AnyPointer::Reader {
public:
  typedef AnyPointer Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool isUnconstrained() const;
  inline typename Unconstrained::Reader getUnconstrained() const;

  inline bool isParameter() const;
  inline typename Parameter::Reader getParameter() const;

  inline bool isImplicitMethodParameter() const;
  inline typename ImplicitMethodParameter::Reader getImplicitMethodParameter() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::AnyPointer::Builder {
public:
  typedef AnyPointer Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool isUnconstrained();
  inline typename Unconstrained::Builder getUnconstrained();
  inline typename Unconstrained::Builder initUnconstrained();

  inline bool isParameter();
  inline typename Parameter::Builder getParameter();
  inline typename Parameter::Builder initParameter();

  inline bool isImplicitMethodParameter();
  inline typename ImplicitMethodParameter::Builder getImplicitMethodParameter();
  inline typename ImplicitMethodParameter::Builder initImplicitMethodParameter();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::AnyPointer::Pipeline {
public:
  typedef AnyPointer Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::AnyPointer::Unconstrained::Reader {
public:
  typedef Unconstrained Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool isAnyKind() const;
  inline ::capnp::Void getAnyKind() const;

  inline bool isStruct() const;
  inline ::capnp::Void getStruct() const;

  inline bool isList() const;
  inline ::capnp::Void getList() const;

  inline bool isCapability() const;
  inline ::capnp::Void getCapability() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::AnyPointer::Unconstrained::Builder {
public:
  typedef Unconstrained Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool isAnyKind();
  inline ::capnp::Void getAnyKind();
  inline void setAnyKind( ::capnp::Void value = ::capnp::VOID);

  inline bool isStruct();
  inline ::capnp::Void getStruct();
  inline void setStruct( ::capnp::Void value = ::capnp::VOID);

  inline bool isList();
  inline ::capnp::Void getList();
  inline void setList( ::capnp::Void value = ::capnp::VOID);

  inline bool isCapability();
  inline ::capnp::Void getCapability();
  inline void setCapability( ::capnp::Void value = ::capnp::VOID);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::AnyPointer::Unconstrained::Pipeline {
public:
  typedef Unconstrained Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::AnyPointer::Parameter::Reader {
public:
  typedef Parameter Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getScopeId() const;

  inline ::uint16_t getParameterIndex() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::AnyPointer::Parameter::Builder {
public:
  typedef Parameter Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getScopeId();
  inline void setScopeId( ::uint64_t value);

  inline ::uint16_t getParameterIndex();
  inline void setParameterIndex( ::uint16_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::AnyPointer::Parameter::Pipeline {
public:
  typedef Parameter Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Type::AnyPointer::ImplicitMethodParameter::Reader {
public:
  typedef ImplicitMethodParameter Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint16_t getParameterIndex() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Type::AnyPointer::ImplicitMethodParameter::Builder {
public:
  typedef ImplicitMethodParameter Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint16_t getParameterIndex();
  inline void setParameterIndex( ::uint16_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Type::AnyPointer::ImplicitMethodParameter::Pipeline {
public:
  typedef ImplicitMethodParameter Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Brand::Reader {
public:
  typedef Brand Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasScopes() const;
  inline ::capnp::List< ::capnp::schema::Brand::Scope>::Reader getScopes() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Brand::Builder {
public:
  typedef Brand Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasScopes();
  inline ::capnp::List< ::capnp::schema::Brand::Scope>::Builder getScopes();
  inline void setScopes( ::capnp::List< ::capnp::schema::Brand::Scope>::Reader value);
  inline ::capnp::List< ::capnp::schema::Brand::Scope>::Builder initScopes(unsigned int size);
  inline void adoptScopes(::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Scope>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Scope>> disownScopes();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Brand::Pipeline {
public:
  typedef Brand Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Brand::Scope::Reader {
public:
  typedef Scope Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline ::uint64_t getScopeId() const;

  inline bool isBind() const;
  inline bool hasBind() const;
  inline ::capnp::List< ::capnp::schema::Brand::Binding>::Reader getBind() const;

  inline bool isInherit() const;
  inline ::capnp::Void getInherit() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Brand::Scope::Builder {
public:
  typedef Scope Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline ::uint64_t getScopeId();
  inline void setScopeId( ::uint64_t value);

  inline bool isBind();
  inline bool hasBind();
  inline ::capnp::List< ::capnp::schema::Brand::Binding>::Builder getBind();
  inline void setBind( ::capnp::List< ::capnp::schema::Brand::Binding>::Reader value);
  inline ::capnp::List< ::capnp::schema::Brand::Binding>::Builder initBind(unsigned int size);
  inline void adoptBind(::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Binding>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Binding>> disownBind();

  inline bool isInherit();
  inline ::capnp::Void getInherit();
  inline void setInherit( ::capnp::Void value = ::capnp::VOID);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Brand::Scope::Pipeline {
public:
  typedef Scope Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Brand::Binding::Reader {
public:
  typedef Binding Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool isUnbound() const;
  inline ::capnp::Void getUnbound() const;

  inline bool isType() const;
  inline bool hasType() const;
  inline ::capnp::schema::Type::Reader getType() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Brand::Binding::Builder {
public:
  typedef Binding Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool isUnbound();
  inline ::capnp::Void getUnbound();
  inline void setUnbound( ::capnp::Void value = ::capnp::VOID);

  inline bool isType();
  inline bool hasType();
  inline ::capnp::schema::Type::Builder getType();
  inline void setType( ::capnp::schema::Type::Reader value);
  inline ::capnp::schema::Type::Builder initType();
  inline void adoptType(::capnp::Orphan< ::capnp::schema::Type>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Type> disownType();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Brand::Binding::Pipeline {
public:
  typedef Binding Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Value::Reader {
public:
  typedef Value Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline Which which() const;
  inline bool isVoid() const;
  inline ::capnp::Void getVoid() const;

  inline bool isBool() const;
  inline bool getBool() const;

  inline bool isInt8() const;
  inline ::int8_t getInt8() const;

  inline bool isInt16() const;
  inline ::int16_t getInt16() const;

  inline bool isInt32() const;
  inline ::int32_t getInt32() const;

  inline bool isInt64() const;
  inline ::int64_t getInt64() const;

  inline bool isUint8() const;
  inline ::uint8_t getUint8() const;

  inline bool isUint16() const;
  inline ::uint16_t getUint16() const;

  inline bool isUint32() const;
  inline ::uint32_t getUint32() const;

  inline bool isUint64() const;
  inline ::uint64_t getUint64() const;

  inline bool isFloat32() const;
  inline float getFloat32() const;

  inline bool isFloat64() const;
  inline double getFloat64() const;

  inline bool isText() const;
  inline bool hasText() const;
  inline ::capnp::Text::Reader getText() const;

  inline bool isData() const;
  inline bool hasData() const;
  inline ::capnp::Data::Reader getData() const;

  inline bool isList() const;
  inline bool hasList() const;
  inline ::capnp::AnyPointer::Reader getList() const;

  inline bool isEnum() const;
  inline ::uint16_t getEnum() const;

  inline bool isStruct() const;
  inline bool hasStruct() const;
  inline ::capnp::AnyPointer::Reader getStruct() const;

  inline bool isInterface() const;
  inline ::capnp::Void getInterface() const;

  inline bool isAnyPointer() const;
  inline bool hasAnyPointer() const;
  inline ::capnp::AnyPointer::Reader getAnyPointer() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Value::Builder {
public:
  typedef Value Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline Which which();
  inline bool isVoid();
  inline ::capnp::Void getVoid();
  inline void setVoid( ::capnp::Void value = ::capnp::VOID);

  inline bool isBool();
  inline bool getBool();
  inline void setBool(bool value);

  inline bool isInt8();
  inline ::int8_t getInt8();
  inline void setInt8( ::int8_t value);

  inline bool isInt16();
  inline ::int16_t getInt16();
  inline void setInt16( ::int16_t value);

  inline bool isInt32();
  inline ::int32_t getInt32();
  inline void setInt32( ::int32_t value);

  inline bool isInt64();
  inline ::int64_t getInt64();
  inline void setInt64( ::int64_t value);

  inline bool isUint8();
  inline ::uint8_t getUint8();
  inline void setUint8( ::uint8_t value);

  inline bool isUint16();
  inline ::uint16_t getUint16();
  inline void setUint16( ::uint16_t value);

  inline bool isUint32();
  inline ::uint32_t getUint32();
  inline void setUint32( ::uint32_t value);

  inline bool isUint64();
  inline ::uint64_t getUint64();
  inline void setUint64( ::uint64_t value);

  inline bool isFloat32();
  inline float getFloat32();
  inline void setFloat32(float value);

  inline bool isFloat64();
  inline double getFloat64();
  inline void setFloat64(double value);

  inline bool isText();
  inline bool hasText();
  inline ::capnp::Text::Builder getText();
  inline void setText( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initText(unsigned int size);
  inline void adoptText(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownText();

  inline bool isData();
  inline bool hasData();
  inline ::capnp::Data::Builder getData();
  inline void setData( ::capnp::Data::Reader value);
  inline ::capnp::Data::Builder initData(unsigned int size);
  inline void adoptData(::capnp::Orphan< ::capnp::Data>&& value);
  inline ::capnp::Orphan< ::capnp::Data> disownData();

  inline bool isList();
  inline bool hasList();
  inline ::capnp::AnyPointer::Builder getList();
  inline ::capnp::AnyPointer::Builder initList();

  inline bool isEnum();
  inline ::uint16_t getEnum();
  inline void setEnum( ::uint16_t value);

  inline bool isStruct();
  inline bool hasStruct();
  inline ::capnp::AnyPointer::Builder getStruct();
  inline ::capnp::AnyPointer::Builder initStruct();

  inline bool isInterface();
  inline ::capnp::Void getInterface();
  inline void setInterface( ::capnp::Void value = ::capnp::VOID);

  inline bool isAnyPointer();
  inline bool hasAnyPointer();
  inline ::capnp::AnyPointer::Builder getAnyPointer();
  inline ::capnp::AnyPointer::Builder initAnyPointer();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Value::Pipeline {
public:
  typedef Value Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class Annotation::Reader {
public:
  typedef Annotation Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getId() const;

  inline bool hasValue() const;
  inline ::capnp::schema::Value::Reader getValue() const;

  inline bool hasBrand() const;
  inline ::capnp::schema::Brand::Reader getBrand() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class Annotation::Builder {
public:
  typedef Annotation Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getId();
  inline void setId( ::uint64_t value);

  inline bool hasValue();
  inline ::capnp::schema::Value::Builder getValue();
  inline void setValue( ::capnp::schema::Value::Reader value);
  inline ::capnp::schema::Value::Builder initValue();
  inline void adoptValue(::capnp::Orphan< ::capnp::schema::Value>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Value> disownValue();

  inline bool hasBrand();
  inline ::capnp::schema::Brand::Builder getBrand();
  inline void setBrand( ::capnp::schema::Brand::Reader value);
  inline ::capnp::schema::Brand::Builder initBrand();
  inline void adoptBrand(::capnp::Orphan< ::capnp::schema::Brand>&& value);
  inline ::capnp::Orphan< ::capnp::schema::Brand> disownBrand();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class Annotation::Pipeline {
public:
  typedef Annotation Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::Value::Pipeline getValue();
  inline ::capnp::schema::Brand::Pipeline getBrand();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class CapnpVersion::Reader {
public:
  typedef CapnpVersion Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint16_t getMajor() const;

  inline ::uint8_t getMinor() const;

  inline ::uint8_t getMicro() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class CapnpVersion::Builder {
public:
  typedef CapnpVersion Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint16_t getMajor();
  inline void setMajor( ::uint16_t value);

  inline ::uint8_t getMinor();
  inline void setMinor( ::uint8_t value);

  inline ::uint8_t getMicro();
  inline void setMicro( ::uint8_t value);

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class CapnpVersion::Pipeline {
public:
  typedef CapnpVersion Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class CodeGeneratorRequest::Reader {
public:
  typedef CodeGeneratorRequest Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline bool hasNodes() const;
  inline ::capnp::List< ::capnp::schema::Node>::Reader getNodes() const;

  inline bool hasRequestedFiles() const;
  inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Reader getRequestedFiles() const;

  inline bool hasCapnpVersion() const;
  inline ::capnp::schema::CapnpVersion::Reader getCapnpVersion() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class CodeGeneratorRequest::Builder {
public:
  typedef CodeGeneratorRequest Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline bool hasNodes();
  inline ::capnp::List< ::capnp::schema::Node>::Builder getNodes();
  inline void setNodes( ::capnp::List< ::capnp::schema::Node>::Reader value);
  inline ::capnp::List< ::capnp::schema::Node>::Builder initNodes(unsigned int size);
  inline void adoptNodes(::capnp::Orphan< ::capnp::List< ::capnp::schema::Node>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node>> disownNodes();

  inline bool hasRequestedFiles();
  inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Builder getRequestedFiles();
  inline void setRequestedFiles( ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Reader value);
  inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Builder initRequestedFiles(unsigned int size);
  inline void adoptRequestedFiles(::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>> disownRequestedFiles();

  inline bool hasCapnpVersion();
  inline ::capnp::schema::CapnpVersion::Builder getCapnpVersion();
  inline void setCapnpVersion( ::capnp::schema::CapnpVersion::Reader value);
  inline ::capnp::schema::CapnpVersion::Builder initCapnpVersion();
  inline void adoptCapnpVersion(::capnp::Orphan< ::capnp::schema::CapnpVersion>&& value);
  inline ::capnp::Orphan< ::capnp::schema::CapnpVersion> disownCapnpVersion();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class CodeGeneratorRequest::Pipeline {
public:
  typedef CodeGeneratorRequest Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

  inline ::capnp::schema::CapnpVersion::Pipeline getCapnpVersion();
private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class CodeGeneratorRequest::RequestedFile::Reader {
public:
  typedef RequestedFile Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getId() const;

  inline bool hasFilename() const;
  inline ::capnp::Text::Reader getFilename() const;

  inline bool hasImports() const;
  inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Reader getImports() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class CodeGeneratorRequest::RequestedFile::Builder {
public:
  typedef RequestedFile Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getId();
  inline void setId( ::uint64_t value);

  inline bool hasFilename();
  inline ::capnp::Text::Builder getFilename();
  inline void setFilename( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initFilename(unsigned int size);
  inline void adoptFilename(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownFilename();

  inline bool hasImports();
  inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Builder getImports();
  inline void setImports( ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Reader value);
  inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Builder initImports(unsigned int size);
  inline void adoptImports(::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>&& value);
  inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>> disownImports();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class CodeGeneratorRequest::RequestedFile::Pipeline {
public:
  typedef RequestedFile Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};


class CodeGeneratorRequest::RequestedFile::Import::Reader {
public:
  typedef Import Reads;

  Reader() = default;
  inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}

  inline ::capnp::MessageSize totalSize() const {
    return _reader.totalSize().asPublic();
  }


  inline ::kj::StringTree toString() const {
    return ::capnp::_::structString(_reader, *_capnpPrivate::brand());
  }


  inline ::uint64_t getId() const;

  inline bool hasName() const;
  inline ::capnp::Text::Reader getName() const;

private:
  ::capnp::_::StructReader _reader;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::List;
  friend class ::capnp::MessageBuilder;
  friend class ::capnp::Orphanage;
};

class CodeGeneratorRequest::RequestedFile::Import::Builder {
public:
  typedef Import Builds;

  Builder() = delete;

  inline Builder(decltype(nullptr)) {}
  inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {}
  inline operator Reader() const { return Reader(_builder.asReader()); }
  inline Reader asReader() const { return *this; }

  inline ::capnp::MessageSize totalSize() const { return asReader().totalSize(); }

  inline ::kj::StringTree toString() const { return asReader().toString(); }


  inline ::uint64_t getId();
  inline void setId( ::uint64_t value);

  inline bool hasName();
  inline ::capnp::Text::Builder getName();
  inline void setName( ::capnp::Text::Reader value);
  inline ::capnp::Text::Builder initName(unsigned int size);
  inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
  inline ::capnp::Orphan< ::capnp::Text> disownName();

private:
  ::capnp::_::StructBuilder _builder;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
  friend class ::capnp::Orphanage;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::_::PointerHelpers;
};


class CodeGeneratorRequest::RequestedFile::Import::Pipeline {
public:
  typedef Import Pipelines;

  inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
  inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
      : _typeless(kj::mv(typeless)) {}

private:
  ::capnp::AnyPointer::Pipeline _typeless;
  friend class ::capnp::PipelineHook;
  template <typename, ::capnp::Kind>
  friend struct ::capnp::ToDynamic_;
};




inline ::capnp::schema::Node::Which Node::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Node::Which Node::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Node::Reader::getId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Node::Builder::getId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Node::Builder::setId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Reader::hasDisplayName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Builder::hasDisplayName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Node::Reader::getDisplayName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Node::Builder::getDisplayName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Node::Builder::setDisplayName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Node::Builder::initDisplayName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Node::Builder::adoptDisplayName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Node::Builder::disownDisplayName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint32_t Node::Reader::getDisplayNamePrefixLength() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint32_t Node::Builder::getDisplayNamePrefixLength() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Node::Builder::setDisplayNamePrefixLength( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline ::uint64_t Node::Reader::getScopeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Node::Builder::getScopeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Node::Builder::setScopeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Reader::hasNestedNodes() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Builder::hasNestedNodes() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader Node::Reader::getNestedNodes() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::NestedNode>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Node::NestedNode>::Builder Node::Builder::getNestedNodes() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::NestedNode>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Node::Builder::setNestedNodes( ::capnp::List< ::capnp::schema::Node::NestedNode>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::NestedNode>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Node::NestedNode>::Builder Node::Builder::initNestedNodes(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::NestedNode>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void Node::Builder::adoptNestedNodes(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::NestedNode>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::NestedNode>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::NestedNode>> Node::Builder::disownNestedNodes() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::NestedNode>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool Node::Reader::hasAnnotations() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Builder::hasAnnotations() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Annotation>::Reader Node::Reader::getAnnotations() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Node::Builder::getAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void Node::Builder::setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Node::Builder::initAnnotations(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), size);
}
inline void Node::Builder::adoptAnnotations(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> Node::Builder::disownAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool Node::Reader::isFile() const {
  return which() == Node::FILE;
}
inline bool Node::Builder::isFile() {
  return which() == Node::FILE;
}
inline ::capnp::Void Node::Reader::getFile() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Node::Builder::getFile() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Node::Builder::setFile( ::capnp::Void value) {
  _builder.setDataField<Node::Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, Node::FILE);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Reader::isStruct() const {
  return which() == Node::STRUCT;
}
inline bool Node::Builder::isStruct() {
  return which() == Node::STRUCT;
}
inline typename Node::Struct::Reader Node::Reader::getStruct() const {

                                                                   ;
  return typename Node::Struct::Reader(_reader);
}
inline typename Node::Struct::Builder Node::Builder::getStruct() {

                                                                   ;
  return typename Node::Struct::Builder(_builder);
}
inline typename Node::Struct::Builder Node::Builder::initStruct() {
  _builder.setDataField<Node::Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, Node::STRUCT);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<7>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<12>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<13>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<224>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<15>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint32_t>(::capnp::bounded<8>() * ::capnp::ELEMENTS, 0);
  _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
  return typename Node::Struct::Builder(_builder);
}
inline bool Node::Reader::isEnum() const {
  return which() == Node::ENUM;
}
inline bool Node::Builder::isEnum() {
  return which() == Node::ENUM;
}
inline typename Node::Enum::Reader Node::Reader::getEnum() const {

                                                                   ;
  return typename Node::Enum::Reader(_reader);
}
inline typename Node::Enum::Builder Node::Builder::getEnum() {

                                                                   ;
  return typename Node::Enum::Builder(_builder);
}
inline typename Node::Enum::Builder Node::Builder::initEnum() {
  _builder.setDataField<Node::Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, Node::ENUM);
  _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
  return typename Node::Enum::Builder(_builder);
}
inline bool Node::Reader::isInterface() const {
  return which() == Node::INTERFACE;
}
inline bool Node::Builder::isInterface() {
  return which() == Node::INTERFACE;
}
inline typename Node::Interface::Reader Node::Reader::getInterface() const {

                                                                   ;
  return typename Node::Interface::Reader(_reader);
}
inline typename Node::Interface::Builder Node::Builder::getInterface() {

                                                                   ;
  return typename Node::Interface::Builder(_builder);
}
inline typename Node::Interface::Builder Node::Builder::initInterface() {
  _builder.setDataField<Node::Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, Node::INTERFACE);
  _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
  _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS).clear();
  return typename Node::Interface::Builder(_builder);
}
inline bool Node::Reader::isConst() const {
  return which() == Node::CONST;
}
inline bool Node::Builder::isConst() {
  return which() == Node::CONST;
}
inline typename Node::Const::Reader Node::Reader::getConst() const {

                                                                   ;
  return typename Node::Const::Reader(_reader);
}
inline typename Node::Const::Builder Node::Builder::getConst() {

                                                                   ;
  return typename Node::Const::Builder(_builder);
}
inline typename Node::Const::Builder Node::Builder::initConst() {
  _builder.setDataField<Node::Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, Node::CONST);
  _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
  _builder.getPointerField(::capnp::bounded<4>() * ::capnp::POINTERS).clear();
  return typename Node::Const::Builder(_builder);
}
inline bool Node::Reader::isAnnotation() const {
  return which() == Node::ANNOTATION;
}
inline bool Node::Builder::isAnnotation() {
  return which() == Node::ANNOTATION;
}
inline typename Node::Annotation::Reader Node::Reader::getAnnotation() const {

                                                                   ;
  return typename Node::Annotation::Reader(_reader);
}
inline typename Node::Annotation::Builder Node::Builder::getAnnotation() {

                                                                   ;
  return typename Node::Annotation::Builder(_builder);
}
inline typename Node::Annotation::Builder Node::Builder::initAnnotation() {
  _builder.setDataField<Node::Which>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, Node::ANNOTATION);
  _builder.setDataField<bool>(::capnp::bounded<112>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<113>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<114>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<115>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<116>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<117>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<118>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<119>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<120>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<121>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<122>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<123>() * ::capnp::ELEMENTS, 0);
  _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
  return typename Node::Annotation::Builder(_builder);
}
inline bool Node::Reader::hasParameters() const {
  return !_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Builder::hasParameters() {
  return !_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Node::Parameter>::Reader Node::Reader::getParameters() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::get(_reader.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder Node::Builder::getParameters() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::get(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}
inline void Node::Builder::setParameters( ::capnp::List< ::capnp::schema::Node::Parameter>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::set(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder Node::Builder::initParameters(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::init(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), size);
}
inline void Node::Builder::adoptParameters(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::adopt(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>> Node::Builder::disownParameters() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::disown(_builder.getPointerField(
      ::capnp::bounded<5>() * ::capnp::POINTERS));
}

inline bool Node::Reader::getIsGeneric() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<288>() * ::capnp::ELEMENTS);
}

inline bool Node::Builder::getIsGeneric() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<288>() * ::capnp::ELEMENTS);
}
inline void Node::Builder::setIsGeneric(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<288>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Parameter::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Parameter::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Node::Parameter::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Node::Parameter::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Node::Parameter::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Node::Parameter::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Node::Parameter::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Node::Parameter::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool Node::NestedNode::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Node::NestedNode::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Node::NestedNode::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Node::NestedNode::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Node::NestedNode::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Node::NestedNode::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Node::NestedNode::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Node::NestedNode::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint64_t Node::NestedNode::Reader::getId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Node::NestedNode::Builder::getId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Node::NestedNode::Builder::setId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline ::uint16_t Node::Struct::Reader::getDataWordCount() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Node::Struct::Builder::getDataWordCount() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS);
}
inline void Node::Struct::Builder::setDataWordCount( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<7>() * ::capnp::ELEMENTS, value);
}

inline ::uint16_t Node::Struct::Reader::getPointerCount() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Node::Struct::Builder::getPointerCount() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS);
}
inline void Node::Struct::Builder::setPointerCount( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<12>() * ::capnp::ELEMENTS, value);
}

inline ::capnp::schema::ElementSize Node::Struct::Reader::getPreferredListEncoding() const {
  return _reader.getDataField< ::capnp::schema::ElementSize>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}

inline ::capnp::schema::ElementSize Node::Struct::Builder::getPreferredListEncoding() {
  return _builder.getDataField< ::capnp::schema::ElementSize>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS);
}
inline void Node::Struct::Builder::setPreferredListEncoding( ::capnp::schema::ElementSize value) {
  _builder.setDataField< ::capnp::schema::ElementSize>(
      ::capnp::bounded<13>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Struct::Reader::getIsGroup() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<224>() * ::capnp::ELEMENTS);
}

inline bool Node::Struct::Builder::getIsGroup() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<224>() * ::capnp::ELEMENTS);
}
inline void Node::Struct::Builder::setIsGroup(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<224>() * ::capnp::ELEMENTS, value);
}

inline ::uint16_t Node::Struct::Reader::getDiscriminantCount() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Node::Struct::Builder::getDiscriminantCount() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS);
}
inline void Node::Struct::Builder::setDiscriminantCount( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<15>() * ::capnp::ELEMENTS, value);
}

inline ::uint32_t Node::Struct::Reader::getDiscriminantOffset() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}

inline ::uint32_t Node::Struct::Builder::getDiscriminantOffset() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS);
}
inline void Node::Struct::Builder::setDiscriminantOffset( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<8>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Struct::Reader::hasFields() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Struct::Builder::hasFields() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Field>::Reader Node::Struct::Reader::getFields() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Field>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Field>::Builder Node::Struct::Builder::getFields() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Field>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Node::Struct::Builder::setFields( ::capnp::List< ::capnp::schema::Field>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Field>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Field>::Builder Node::Struct::Builder::initFields(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Field>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void Node::Struct::Builder::adoptFields(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Field>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Field>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Field>> Node::Struct::Builder::disownFields() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Field>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Node::Enum::Reader::hasEnumerants() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Enum::Builder::hasEnumerants() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Enumerant>::Reader Node::Enum::Reader::getEnumerants() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Enumerant>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Enumerant>::Builder Node::Enum::Builder::getEnumerants() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Enumerant>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Node::Enum::Builder::setEnumerants( ::capnp::List< ::capnp::schema::Enumerant>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Enumerant>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Enumerant>::Builder Node::Enum::Builder::initEnumerants(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Enumerant>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void Node::Enum::Builder::adoptEnumerants(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Enumerant>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Enumerant>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Enumerant>> Node::Enum::Builder::disownEnumerants() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Enumerant>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Node::Interface::Reader::hasMethods() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Interface::Builder::hasMethods() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Method>::Reader Node::Interface::Reader::getMethods() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Method>>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Method>::Builder Node::Interface::Builder::getMethods() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Method>>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Node::Interface::Builder::setMethods( ::capnp::List< ::capnp::schema::Method>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Method>>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Method>::Builder Node::Interface::Builder::initMethods(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Method>>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), size);
}
inline void Node::Interface::Builder::adoptMethods(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Method>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Method>>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Method>> Node::Interface::Builder::disownMethods() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Method>>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Node::Interface::Reader::hasSuperclasses() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Interface::Builder::hasSuperclasses() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Superclass>::Reader Node::Interface::Reader::getSuperclasses() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Superclass>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Superclass>::Builder Node::Interface::Builder::getSuperclasses() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Superclass>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void Node::Interface::Builder::setSuperclasses( ::capnp::List< ::capnp::schema::Superclass>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Superclass>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Superclass>::Builder Node::Interface::Builder::initSuperclasses(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Superclass>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void Node::Interface::Builder::adoptSuperclasses(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Superclass>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Superclass>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Superclass>> Node::Interface::Builder::disownSuperclasses() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Superclass>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool Node::Const::Reader::hasType() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Const::Builder::hasType() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Type::Reader Node::Const::Reader::getType() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Type::Builder Node::Const::Builder::getType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Type::Pipeline Node::Const::Pipeline::getType() {
  return ::capnp::schema::Type::Pipeline(_typeless.getPointerField(3));
}

inline void Node::Const::Builder::setType( ::capnp::schema::Type::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Type::Builder Node::Const::Builder::initType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Node::Const::Builder::adoptType(
    ::capnp::Orphan< ::capnp::schema::Type>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Type> Node::Const::Builder::disownType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Node::Const::Reader::hasValue() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Const::Builder::hasValue() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Value::Reader Node::Const::Reader::getValue() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Value::Builder Node::Const::Builder::getValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Value::Pipeline Node::Const::Pipeline::getValue() {
  return ::capnp::schema::Value::Pipeline(_typeless.getPointerField(4));
}

inline void Node::Const::Builder::setValue( ::capnp::schema::Value::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Value>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Value::Builder Node::Const::Builder::initValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void Node::Const::Builder::adoptValue(
    ::capnp::Orphan< ::capnp::schema::Value>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Value>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Value> Node::Const::Builder::disownValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline bool Node::Annotation::Reader::hasType() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Node::Annotation::Builder::hasType() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Type::Reader Node::Annotation::Reader::getType() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Type::Builder Node::Annotation::Builder::getType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Type::Pipeline Node::Annotation::Pipeline::getType() {
  return ::capnp::schema::Type::Pipeline(_typeless.getPointerField(3));
}

inline void Node::Annotation::Builder::setType( ::capnp::schema::Type::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Type::Builder Node::Annotation::Builder::initType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Node::Annotation::Builder::adoptType(
    ::capnp::Orphan< ::capnp::schema::Type>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Type> Node::Annotation::Builder::disownType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Node::Annotation::Reader::getTargetsFile() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<112>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsFile() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<112>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsFile(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<112>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsConst() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<113>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsConst() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<113>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsConst(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<113>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsEnum() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<114>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsEnum() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<114>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsEnum(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<114>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsEnumerant() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<115>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsEnumerant() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<115>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsEnumerant(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<115>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsStruct() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<116>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsStruct() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<116>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsStruct(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<116>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsField() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<117>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsField() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<117>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsField(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<117>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsUnion() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<118>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsUnion() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<118>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsUnion(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<118>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsGroup() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<119>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsGroup() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<119>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsGroup(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<119>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsInterface() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<120>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsInterface() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<120>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsInterface(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<120>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsMethod() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<121>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsMethod() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<121>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsMethod(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<121>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsParam() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<122>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsParam() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<122>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsParam(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<122>() * ::capnp::ELEMENTS, value);
}

inline bool Node::Annotation::Reader::getTargetsAnnotation() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<123>() * ::capnp::ELEMENTS);
}

inline bool Node::Annotation::Builder::getTargetsAnnotation() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<123>() * ::capnp::ELEMENTS);
}
inline void Node::Annotation::Builder::setTargetsAnnotation(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<123>() * ::capnp::ELEMENTS, value);
}

inline ::capnp::schema::Field::Which Field::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Field::Which Field::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline bool Field::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Field::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Field::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Field::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Field::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Field::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Field::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Field::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint16_t Field::Reader::getCodeOrder() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Field::Builder::getCodeOrder() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Field::Builder::setCodeOrder( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Field::Reader::hasAnnotations() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool Field::Builder::hasAnnotations() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Annotation>::Reader Field::Reader::getAnnotations() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Field::Builder::getAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Field::Builder::setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Field::Builder::initAnnotations(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void Field::Builder::adoptAnnotations(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> Field::Builder::disownAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline ::uint16_t Field::Reader::getDiscriminantValue() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, 65535u);
}

inline ::uint16_t Field::Builder::getDiscriminantValue() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, 65535u);
}
inline void Field::Builder::setDiscriminantValue( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value, 65535u);
}

inline bool Field::Reader::isSlot() const {
  return which() == Field::SLOT;
}
inline bool Field::Builder::isSlot() {
  return which() == Field::SLOT;
}
inline typename Field::Slot::Reader Field::Reader::getSlot() const {

                                                                   ;
  return typename Field::Slot::Reader(_reader);
}
inline typename Field::Slot::Builder Field::Builder::getSlot() {

                                                                   ;
  return typename Field::Slot::Builder(_builder);
}
inline typename Field::Slot::Builder Field::Builder::initSlot() {
  _builder.setDataField<Field::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Field::SLOT);
  _builder.setDataField< ::uint32_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField<bool>(::capnp::bounded<128>() * ::capnp::ELEMENTS, 0);
  _builder.getPointerField(::capnp::bounded<2>() * ::capnp::POINTERS).clear();
  _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
  return typename Field::Slot::Builder(_builder);
}
inline bool Field::Reader::isGroup() const {
  return which() == Field::GROUP;
}
inline bool Field::Builder::isGroup() {
  return which() == Field::GROUP;
}
inline typename Field::Group::Reader Field::Reader::getGroup() const {

                                                                   ;
  return typename Field::Group::Reader(_reader);
}
inline typename Field::Group::Builder Field::Builder::getGroup() {

                                                                   ;
  return typename Field::Group::Builder(_builder);
}
inline typename Field::Group::Builder Field::Builder::initGroup() {
  _builder.setDataField<Field::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Field::GROUP);
  _builder.setDataField< ::uint64_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0);
  return typename Field::Group::Builder(_builder);
}
inline typename Field::Ordinal::Reader Field::Reader::getOrdinal() const {
  return typename Field::Ordinal::Reader(_reader);
}
inline typename Field::Ordinal::Builder Field::Builder::getOrdinal() {
  return typename Field::Ordinal::Builder(_builder);
}

inline typename Field::Ordinal::Pipeline Field::Pipeline::getOrdinal() {
  return typename Field::Ordinal::Pipeline(_typeless.noop());
}

inline typename Field::Ordinal::Builder Field::Builder::initOrdinal() {
  _builder.setDataField< ::uint16_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0);
  return typename Field::Ordinal::Builder(_builder);
}
inline ::uint32_t Field::Slot::Reader::getOffset() const {
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint32_t Field::Slot::Builder::getOffset() {
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Field::Slot::Builder::setOffset( ::uint32_t value) {
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Field::Slot::Reader::hasType() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool Field::Slot::Builder::hasType() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Type::Reader Field::Slot::Reader::getType() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Type::Builder Field::Slot::Builder::getType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Type::Pipeline Field::Slot::Pipeline::getType() {
  return ::capnp::schema::Type::Pipeline(_typeless.getPointerField(2));
}

inline void Field::Slot::Builder::setType( ::capnp::schema::Type::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Type::Builder Field::Slot::Builder::initType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void Field::Slot::Builder::adoptType(
    ::capnp::Orphan< ::capnp::schema::Type>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Type> Field::Slot::Builder::disownType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool Field::Slot::Reader::hasDefaultValue() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Field::Slot::Builder::hasDefaultValue() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Value::Reader Field::Slot::Reader::getDefaultValue() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Value::Builder Field::Slot::Builder::getDefaultValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Value::Pipeline Field::Slot::Pipeline::getDefaultValue() {
  return ::capnp::schema::Value::Pipeline(_typeless.getPointerField(3));
}

inline void Field::Slot::Builder::setDefaultValue( ::capnp::schema::Value::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Value>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Value::Builder Field::Slot::Builder::initDefaultValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Field::Slot::Builder::adoptDefaultValue(
    ::capnp::Orphan< ::capnp::schema::Value>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Value>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Value> Field::Slot::Builder::disownDefaultValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Field::Slot::Reader::getHadExplicitDefault() const {
  return _reader.getDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS);
}

inline bool Field::Slot::Builder::getHadExplicitDefault() {
  return _builder.getDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS);
}
inline void Field::Slot::Builder::setHadExplicitDefault(bool value) {
  _builder.setDataField<bool>(
      ::capnp::bounded<128>() * ::capnp::ELEMENTS, value);
}

inline ::uint64_t Field::Group::Reader::getTypeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Field::Group::Builder::getTypeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Field::Group::Builder::setTypeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline ::capnp::schema::Field::Ordinal::Which Field::Ordinal::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Field::Ordinal::Which Field::Ordinal::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline bool Field::Ordinal::Reader::isImplicit() const {
  return which() == Field::Ordinal::IMPLICIT;
}
inline bool Field::Ordinal::Builder::isImplicit() {
  return which() == Field::Ordinal::IMPLICIT;
}
inline ::capnp::Void Field::Ordinal::Reader::getImplicit() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Field::Ordinal::Builder::getImplicit() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Field::Ordinal::Builder::setImplicit( ::capnp::Void value) {
  _builder.setDataField<Field::Ordinal::Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, Field::Ordinal::IMPLICIT);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Field::Ordinal::Reader::isExplicit() const {
  return which() == Field::Ordinal::EXPLICIT;
}
inline bool Field::Ordinal::Builder::isExplicit() {
  return which() == Field::Ordinal::EXPLICIT;
}
inline ::uint16_t Field::Ordinal::Reader::getExplicit() const {

                                                                   ;
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Field::Ordinal::Builder::getExplicit() {

                                                                   ;
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS);
}
inline void Field::Ordinal::Builder::setExplicit( ::uint16_t value) {
  _builder.setDataField<Field::Ordinal::Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, Field::Ordinal::EXPLICIT);
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<6>() * ::capnp::ELEMENTS, value);
}

inline bool Enumerant::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Enumerant::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Enumerant::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Enumerant::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Enumerant::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Enumerant::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Enumerant::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Enumerant::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint16_t Enumerant::Reader::getCodeOrder() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Enumerant::Builder::getCodeOrder() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Enumerant::Builder::setCodeOrder( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Enumerant::Reader::hasAnnotations() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool Enumerant::Builder::hasAnnotations() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Annotation>::Reader Enumerant::Reader::getAnnotations() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Enumerant::Builder::getAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Enumerant::Builder::setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Enumerant::Builder::initAnnotations(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void Enumerant::Builder::adoptAnnotations(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> Enumerant::Builder::disownAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline ::uint64_t Superclass::Reader::getId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Superclass::Builder::getId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Superclass::Builder::setId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Superclass::Reader::hasBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Superclass::Builder::hasBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Superclass::Reader::getBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Superclass::Builder::getBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Superclass::Pipeline::getBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(0));
}

inline void Superclass::Builder::setBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Superclass::Builder::initBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Superclass::Builder::adoptBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Superclass::Builder::disownBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool Method::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Method::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Method::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Method::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Method::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Method::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Method::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Method::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint16_t Method::Reader::getCodeOrder() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Method::Builder::getCodeOrder() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Method::Builder::setCodeOrder( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline ::uint64_t Method::Reader::getParamStructType() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Method::Builder::getParamStructType() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Method::Builder::setParamStructType( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline ::uint64_t Method::Reader::getResultStructType() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Method::Builder::getResultStructType() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Method::Builder::setResultStructType( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool Method::Reader::hasAnnotations() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool Method::Builder::hasAnnotations() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Annotation>::Reader Method::Reader::getAnnotations() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Method::Builder::getAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Method::Builder::setAnnotations( ::capnp::List< ::capnp::schema::Annotation>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Annotation>::Builder Method::Builder::initAnnotations(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void Method::Builder::adoptAnnotations(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Annotation>> Method::Builder::disownAnnotations() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Annotation>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool Method::Reader::hasParamBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool Method::Builder::hasParamBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Method::Reader::getParamBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Method::Builder::getParamBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Method::Pipeline::getParamBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(2));
}

inline void Method::Builder::setParamBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Method::Builder::initParamBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void Method::Builder::adoptParamBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Method::Builder::disownParamBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline bool Method::Reader::hasResultBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline bool Method::Builder::hasResultBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Method::Reader::getResultBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Method::Builder::getResultBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Method::Pipeline::getResultBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(3));
}

inline void Method::Builder::setResultBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Method::Builder::initResultBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}
inline void Method::Builder::adoptResultBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Method::Builder::disownResultBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<3>() * ::capnp::POINTERS));
}

inline bool Method::Reader::hasImplicitParameters() const {
  return !_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline bool Method::Builder::hasImplicitParameters() {
  return !_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Node::Parameter>::Reader Method::Reader::getImplicitParameters() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::get(_reader.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder Method::Builder::getImplicitParameters() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::get(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}
inline void Method::Builder::setImplicitParameters( ::capnp::List< ::capnp::schema::Node::Parameter>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::set(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Node::Parameter>::Builder Method::Builder::initImplicitParameters(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::init(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), size);
}
inline void Method::Builder::adoptImplicitParameters(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::adopt(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node::Parameter>> Method::Builder::disownImplicitParameters() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node::Parameter>>::disown(_builder.getPointerField(
      ::capnp::bounded<4>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Type::Which Type::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Type::Which Type::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool Type::Reader::isVoid() const {
  return which() == Type::VOID;
}
inline bool Type::Builder::isVoid() {
  return which() == Type::VOID;
}
inline ::capnp::Void Type::Reader::getVoid() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getVoid() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setVoid( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::VOID);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isBool() const {
  return which() == Type::BOOL;
}
inline bool Type::Builder::isBool() {
  return which() == Type::BOOL;
}
inline ::capnp::Void Type::Reader::getBool() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getBool() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setBool( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::BOOL);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isInt8() const {
  return which() == Type::INT8;
}
inline bool Type::Builder::isInt8() {
  return which() == Type::INT8;
}
inline ::capnp::Void Type::Reader::getInt8() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getInt8() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setInt8( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::INT8);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isInt16() const {
  return which() == Type::INT16;
}
inline bool Type::Builder::isInt16() {
  return which() == Type::INT16;
}
inline ::capnp::Void Type::Reader::getInt16() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getInt16() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setInt16( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::INT16);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isInt32() const {
  return which() == Type::INT32;
}
inline bool Type::Builder::isInt32() {
  return which() == Type::INT32;
}
inline ::capnp::Void Type::Reader::getInt32() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getInt32() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setInt32( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::INT32);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isInt64() const {
  return which() == Type::INT64;
}
inline bool Type::Builder::isInt64() {
  return which() == Type::INT64;
}
inline ::capnp::Void Type::Reader::getInt64() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getInt64() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setInt64( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::INT64);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isUint8() const {
  return which() == Type::UINT8;
}
inline bool Type::Builder::isUint8() {
  return which() == Type::UINT8;
}
inline ::capnp::Void Type::Reader::getUint8() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getUint8() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setUint8( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::UINT8);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isUint16() const {
  return which() == Type::UINT16;
}
inline bool Type::Builder::isUint16() {
  return which() == Type::UINT16;
}
inline ::capnp::Void Type::Reader::getUint16() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getUint16() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setUint16( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::UINT16);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isUint32() const {
  return which() == Type::UINT32;
}
inline bool Type::Builder::isUint32() {
  return which() == Type::UINT32;
}
inline ::capnp::Void Type::Reader::getUint32() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getUint32() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setUint32( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::UINT32);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isUint64() const {
  return which() == Type::UINT64;
}
inline bool Type::Builder::isUint64() {
  return which() == Type::UINT64;
}
inline ::capnp::Void Type::Reader::getUint64() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getUint64() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setUint64( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::UINT64);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isFloat32() const {
  return which() == Type::FLOAT32;
}
inline bool Type::Builder::isFloat32() {
  return which() == Type::FLOAT32;
}
inline ::capnp::Void Type::Reader::getFloat32() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getFloat32() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setFloat32( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::FLOAT32);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isFloat64() const {
  return which() == Type::FLOAT64;
}
inline bool Type::Builder::isFloat64() {
  return which() == Type::FLOAT64;
}
inline ::capnp::Void Type::Reader::getFloat64() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getFloat64() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setFloat64( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::FLOAT64);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isText() const {
  return which() == Type::TEXT;
}
inline bool Type::Builder::isText() {
  return which() == Type::TEXT;
}
inline ::capnp::Void Type::Reader::getText() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getText() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setText( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::TEXT);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isData() const {
  return which() == Type::DATA;
}
inline bool Type::Builder::isData() {
  return which() == Type::DATA;
}
inline ::capnp::Void Type::Reader::getData() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::Builder::getData() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::Builder::setData( ::capnp::Void value) {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::DATA);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Reader::isList() const {
  return which() == Type::LIST;
}
inline bool Type::Builder::isList() {
  return which() == Type::LIST;
}
inline typename Type::List::Reader Type::Reader::getList() const {

                                                                   ;
  return typename Type::List::Reader(_reader);
}
inline typename Type::List::Builder Type::Builder::getList() {

                                                                   ;
  return typename Type::List::Builder(_builder);
}
inline typename Type::List::Builder Type::Builder::initList() {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::LIST);
  _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear();
  return typename Type::List::Builder(_builder);
}
inline bool Type::Reader::isEnum() const {
  return which() == Type::ENUM;
}
inline bool Type::Builder::isEnum() {
  return which() == Type::ENUM;
}
inline typename Type::Enum::Reader Type::Reader::getEnum() const {

                                                                   ;
  return typename Type::Enum::Reader(_reader);
}
inline typename Type::Enum::Builder Type::Builder::getEnum() {

                                                                   ;
  return typename Type::Enum::Builder(_builder);
}
inline typename Type::Enum::Builder Type::Builder::initEnum() {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::ENUM);
  _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0);
  _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear();
  return typename Type::Enum::Builder(_builder);
}
inline bool Type::Reader::isStruct() const {
  return which() == Type::STRUCT;
}
inline bool Type::Builder::isStruct() {
  return which() == Type::STRUCT;
}
inline typename Type::Struct::Reader Type::Reader::getStruct() const {

                                                                   ;
  return typename Type::Struct::Reader(_reader);
}
inline typename Type::Struct::Builder Type::Builder::getStruct() {

                                                                   ;
  return typename Type::Struct::Builder(_builder);
}
inline typename Type::Struct::Builder Type::Builder::initStruct() {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::STRUCT);
  _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0);
  _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear();
  return typename Type::Struct::Builder(_builder);
}
inline bool Type::Reader::isInterface() const {
  return which() == Type::INTERFACE;
}
inline bool Type::Builder::isInterface() {
  return which() == Type::INTERFACE;
}
inline typename Type::Interface::Reader Type::Reader::getInterface() const {

                                                                   ;
  return typename Type::Interface::Reader(_reader);
}
inline typename Type::Interface::Builder Type::Builder::getInterface() {

                                                                   ;
  return typename Type::Interface::Builder(_builder);
}
inline typename Type::Interface::Builder Type::Builder::initInterface() {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::INTERFACE);
  _builder.setDataField< ::uint64_t>(::capnp::bounded<1>() * ::capnp::ELEMENTS, 0);
  _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear();
  return typename Type::Interface::Builder(_builder);
}
inline bool Type::Reader::isAnyPointer() const {
  return which() == Type::ANY_POINTER;
}
inline bool Type::Builder::isAnyPointer() {
  return which() == Type::ANY_POINTER;
}
inline typename Type::AnyPointer::Reader Type::Reader::getAnyPointer() const {

                                                                   ;
  return typename Type::AnyPointer::Reader(_reader);
}
inline typename Type::AnyPointer::Builder Type::Builder::getAnyPointer() {

                                                                   ;
  return typename Type::AnyPointer::Builder(_builder);
}
inline typename Type::AnyPointer::Builder Type::Builder::initAnyPointer() {
  _builder.setDataField<Type::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Type::ANY_POINTER);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<4>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint64_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0);
  return typename Type::AnyPointer::Builder(_builder);
}
inline bool Type::List::Reader::hasElementType() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Type::List::Builder::hasElementType() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Type::Reader Type::List::Reader::getElementType() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Type::Builder Type::List::Builder::getElementType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Type::Pipeline Type::List::Pipeline::getElementType() {
  return ::capnp::schema::Type::Pipeline(_typeless.getPointerField(0));
}

inline void Type::List::Builder::setElementType( ::capnp::schema::Type::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Type::Builder Type::List::Builder::initElementType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Type::List::Builder::adoptElementType(
    ::capnp::Orphan< ::capnp::schema::Type>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Type> Type::List::Builder::disownElementType() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint64_t Type::Enum::Reader::getTypeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Type::Enum::Builder::getTypeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Type::Enum::Builder::setTypeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Enum::Reader::hasBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Type::Enum::Builder::hasBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Type::Enum::Reader::getBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Type::Enum::Builder::getBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Type::Enum::Pipeline::getBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(0));
}

inline void Type::Enum::Builder::setBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Type::Enum::Builder::initBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Type::Enum::Builder::adoptBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Type::Enum::Builder::disownBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint64_t Type::Struct::Reader::getTypeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Type::Struct::Builder::getTypeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Type::Struct::Builder::setTypeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Struct::Reader::hasBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Type::Struct::Builder::hasBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Type::Struct::Reader::getBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Type::Struct::Builder::getBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Type::Struct::Pipeline::getBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(0));
}

inline void Type::Struct::Builder::setBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Type::Struct::Builder::initBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Type::Struct::Builder::adoptBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Type::Struct::Builder::disownBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::uint64_t Type::Interface::Reader::getTypeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Type::Interface::Builder::getTypeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Type::Interface::Builder::setTypeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Type::Interface::Reader::hasBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Type::Interface::Builder::hasBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Type::Interface::Reader::getBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Type::Interface::Builder::getBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Type::Interface::Pipeline::getBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(0));
}

inline void Type::Interface::Builder::setBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Type::Interface::Builder::initBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Type::Interface::Builder::adoptBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Type::Interface::Builder::disownBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Type::AnyPointer::Which Type::AnyPointer::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Type::AnyPointer::Which Type::AnyPointer::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline bool Type::AnyPointer::Reader::isUnconstrained() const {
  return which() == Type::AnyPointer::UNCONSTRAINED;
}
inline bool Type::AnyPointer::Builder::isUnconstrained() {
  return which() == Type::AnyPointer::UNCONSTRAINED;
}
inline typename Type::AnyPointer::Unconstrained::Reader Type::AnyPointer::Reader::getUnconstrained() const {

                                                                   ;
  return typename Type::AnyPointer::Unconstrained::Reader(_reader);
}
inline typename Type::AnyPointer::Unconstrained::Builder Type::AnyPointer::Builder::getUnconstrained() {

                                                                   ;
  return typename Type::AnyPointer::Unconstrained::Builder(_builder);
}
inline typename Type::AnyPointer::Unconstrained::Builder Type::AnyPointer::Builder::initUnconstrained() {
  _builder.setDataField<Type::AnyPointer::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Type::AnyPointer::UNCONSTRAINED);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0);
  return typename Type::AnyPointer::Unconstrained::Builder(_builder);
}
inline bool Type::AnyPointer::Reader::isParameter() const {
  return which() == Type::AnyPointer::PARAMETER;
}
inline bool Type::AnyPointer::Builder::isParameter() {
  return which() == Type::AnyPointer::PARAMETER;
}
inline typename Type::AnyPointer::Parameter::Reader Type::AnyPointer::Reader::getParameter() const {

                                                                   ;
  return typename Type::AnyPointer::Parameter::Reader(_reader);
}
inline typename Type::AnyPointer::Parameter::Builder Type::AnyPointer::Builder::getParameter() {

                                                                   ;
  return typename Type::AnyPointer::Parameter::Builder(_builder);
}
inline typename Type::AnyPointer::Parameter::Builder Type::AnyPointer::Builder::initParameter() {
  _builder.setDataField<Type::AnyPointer::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Type::AnyPointer::PARAMETER);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0);
  _builder.setDataField< ::uint64_t>(::capnp::bounded<2>() * ::capnp::ELEMENTS, 0);
  return typename Type::AnyPointer::Parameter::Builder(_builder);
}
inline bool Type::AnyPointer::Reader::isImplicitMethodParameter() const {
  return which() == Type::AnyPointer::IMPLICIT_METHOD_PARAMETER;
}
inline bool Type::AnyPointer::Builder::isImplicitMethodParameter() {
  return which() == Type::AnyPointer::IMPLICIT_METHOD_PARAMETER;
}
inline typename Type::AnyPointer::ImplicitMethodParameter::Reader Type::AnyPointer::Reader::getImplicitMethodParameter() const {

                                                                   ;
  return typename Type::AnyPointer::ImplicitMethodParameter::Reader(_reader);
}
inline typename Type::AnyPointer::ImplicitMethodParameter::Builder Type::AnyPointer::Builder::getImplicitMethodParameter() {

                                                                   ;
  return typename Type::AnyPointer::ImplicitMethodParameter::Builder(_builder);
}
inline typename Type::AnyPointer::ImplicitMethodParameter::Builder Type::AnyPointer::Builder::initImplicitMethodParameter() {
  _builder.setDataField<Type::AnyPointer::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Type::AnyPointer::IMPLICIT_METHOD_PARAMETER);
  _builder.setDataField< ::uint16_t>(::capnp::bounded<5>() * ::capnp::ELEMENTS, 0);
  return typename Type::AnyPointer::ImplicitMethodParameter::Builder(_builder);
}
inline ::capnp::schema::Type::AnyPointer::Unconstrained::Which Type::AnyPointer::Unconstrained::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Type::AnyPointer::Unconstrained::Which Type::AnyPointer::Unconstrained::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline bool Type::AnyPointer::Unconstrained::Reader::isAnyKind() const {
  return which() == Type::AnyPointer::Unconstrained::ANY_KIND;
}
inline bool Type::AnyPointer::Unconstrained::Builder::isAnyKind() {
  return which() == Type::AnyPointer::Unconstrained::ANY_KIND;
}
inline ::capnp::Void Type::AnyPointer::Unconstrained::Reader::getAnyKind() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::AnyPointer::Unconstrained::Builder::getAnyKind() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::Unconstrained::Builder::setAnyKind( ::capnp::Void value) {
  _builder.setDataField<Type::AnyPointer::Unconstrained::Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, Type::AnyPointer::Unconstrained::ANY_KIND);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::AnyPointer::Unconstrained::Reader::isStruct() const {
  return which() == Type::AnyPointer::Unconstrained::STRUCT;
}
inline bool Type::AnyPointer::Unconstrained::Builder::isStruct() {
  return which() == Type::AnyPointer::Unconstrained::STRUCT;
}
inline ::capnp::Void Type::AnyPointer::Unconstrained::Reader::getStruct() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::AnyPointer::Unconstrained::Builder::getStruct() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::Unconstrained::Builder::setStruct( ::capnp::Void value) {
  _builder.setDataField<Type::AnyPointer::Unconstrained::Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, Type::AnyPointer::Unconstrained::STRUCT);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::AnyPointer::Unconstrained::Reader::isList() const {
  return which() == Type::AnyPointer::Unconstrained::LIST;
}
inline bool Type::AnyPointer::Unconstrained::Builder::isList() {
  return which() == Type::AnyPointer::Unconstrained::LIST;
}
inline ::capnp::Void Type::AnyPointer::Unconstrained::Reader::getList() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::AnyPointer::Unconstrained::Builder::getList() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::Unconstrained::Builder::setList( ::capnp::Void value) {
  _builder.setDataField<Type::AnyPointer::Unconstrained::Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, Type::AnyPointer::Unconstrained::LIST);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Type::AnyPointer::Unconstrained::Reader::isCapability() const {
  return which() == Type::AnyPointer::Unconstrained::CAPABILITY;
}
inline bool Type::AnyPointer::Unconstrained::Builder::isCapability() {
  return which() == Type::AnyPointer::Unconstrained::CAPABILITY;
}
inline ::capnp::Void Type::AnyPointer::Unconstrained::Reader::getCapability() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Type::AnyPointer::Unconstrained::Builder::getCapability() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::Unconstrained::Builder::setCapability( ::capnp::Void value) {
  _builder.setDataField<Type::AnyPointer::Unconstrained::Which>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, Type::AnyPointer::Unconstrained::CAPABILITY);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline ::uint64_t Type::AnyPointer::Parameter::Reader::getScopeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Type::AnyPointer::Parameter::Builder::getScopeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::Parameter::Builder::setScopeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline ::uint16_t Type::AnyPointer::Parameter::Reader::getParameterIndex() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Type::AnyPointer::Parameter::Builder::getParameterIndex() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::Parameter::Builder::setParameterIndex( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline ::uint16_t Type::AnyPointer::ImplicitMethodParameter::Reader::getParameterIndex() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Type::AnyPointer::ImplicitMethodParameter::Builder::getParameterIndex() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS);
}
inline void Type::AnyPointer::ImplicitMethodParameter::Builder::setParameterIndex( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<5>() * ::capnp::ELEMENTS, value);
}

inline bool Brand::Reader::hasScopes() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Brand::Builder::hasScopes() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Brand::Scope>::Reader Brand::Reader::getScopes() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Scope>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Brand::Scope>::Builder Brand::Builder::getScopes() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Scope>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Brand::Builder::setScopes( ::capnp::List< ::capnp::schema::Brand::Scope>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Scope>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Brand::Scope>::Builder Brand::Builder::initScopes(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Scope>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Brand::Builder::adoptScopes(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Scope>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Scope>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Scope>> Brand::Builder::disownScopes() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Scope>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Scope::Which Brand::Scope::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Brand::Scope::Which Brand::Scope::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Brand::Scope::Reader::getScopeId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Brand::Scope::Builder::getScopeId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Brand::Scope::Builder::setScopeId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Brand::Scope::Reader::isBind() const {
  return which() == Brand::Scope::BIND;
}
inline bool Brand::Scope::Builder::isBind() {
  return which() == Brand::Scope::BIND;
}
inline bool Brand::Scope::Reader::hasBind() const {
  if (which() != Brand::Scope::BIND) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Brand::Scope::Builder::hasBind() {
  if (which() != Brand::Scope::BIND) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Brand::Binding>::Reader Brand::Scope::Reader::getBind() const {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Binding>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Brand::Binding>::Builder Brand::Scope::Builder::getBind() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Binding>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Brand::Scope::Builder::setBind( ::capnp::List< ::capnp::schema::Brand::Binding>::Reader value) {
  _builder.setDataField<Brand::Scope::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Brand::Scope::BIND);
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Binding>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Brand::Binding>::Builder Brand::Scope::Builder::initBind(unsigned int size) {
  _builder.setDataField<Brand::Scope::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Brand::Scope::BIND);
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Binding>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Brand::Scope::Builder::adoptBind(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Binding>>&& value) {
  _builder.setDataField<Brand::Scope::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Brand::Scope::BIND);
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Binding>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Brand::Binding>> Brand::Scope::Builder::disownBind() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Brand::Binding>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool Brand::Scope::Reader::isInherit() const {
  return which() == Brand::Scope::INHERIT;
}
inline bool Brand::Scope::Builder::isInherit() {
  return which() == Brand::Scope::INHERIT;
}
inline ::capnp::Void Brand::Scope::Reader::getInherit() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Brand::Scope::Builder::getInherit() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Brand::Scope::Builder::setInherit( ::capnp::Void value) {
  _builder.setDataField<Brand::Scope::Which>(
      ::capnp::bounded<4>() * ::capnp::ELEMENTS, Brand::Scope::INHERIT);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline ::capnp::schema::Brand::Binding::Which Brand::Binding::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Brand::Binding::Which Brand::Binding::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool Brand::Binding::Reader::isUnbound() const {
  return which() == Brand::Binding::UNBOUND;
}
inline bool Brand::Binding::Builder::isUnbound() {
  return which() == Brand::Binding::UNBOUND;
}
inline ::capnp::Void Brand::Binding::Reader::getUnbound() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Brand::Binding::Builder::getUnbound() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Brand::Binding::Builder::setUnbound( ::capnp::Void value) {
  _builder.setDataField<Brand::Binding::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Brand::Binding::UNBOUND);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Brand::Binding::Reader::isType() const {
  return which() == Brand::Binding::TYPE;
}
inline bool Brand::Binding::Builder::isType() {
  return which() == Brand::Binding::TYPE;
}
inline bool Brand::Binding::Reader::hasType() const {
  if (which() != Brand::Binding::TYPE) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Brand::Binding::Builder::hasType() {
  if (which() != Brand::Binding::TYPE) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Type::Reader Brand::Binding::Reader::getType() const {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Type::Builder Brand::Binding::Builder::getType() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Brand::Binding::Builder::setType( ::capnp::schema::Type::Reader value) {
  _builder.setDataField<Brand::Binding::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Brand::Binding::TYPE);
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Type::Builder Brand::Binding::Builder::initType() {
  _builder.setDataField<Brand::Binding::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Brand::Binding::TYPE);
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Brand::Binding::Builder::adoptType(
    ::capnp::Orphan< ::capnp::schema::Type>&& value) {
  _builder.setDataField<Brand::Binding::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Brand::Binding::TYPE);
  ::capnp::_::PointerHelpers< ::capnp::schema::Type>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Type> Brand::Binding::Builder::disownType() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::schema::Type>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Value::Which Value::Reader::which() const {
  return _reader.getDataField<Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline ::capnp::schema::Value::Which Value::Builder::which() {
  return _builder.getDataField<Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline bool Value::Reader::isVoid() const {
  return which() == Value::VOID;
}
inline bool Value::Builder::isVoid() {
  return which() == Value::VOID;
}
inline ::capnp::Void Value::Reader::getVoid() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Value::Builder::getVoid() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setVoid( ::capnp::Void value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::VOID);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isBool() const {
  return which() == Value::BOOL;
}
inline bool Value::Builder::isBool() {
  return which() == Value::BOOL;
}
inline bool Value::Reader::getBool() const {

                                                                   ;
  return _reader.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}

inline bool Value::Builder::getBool() {

                                                                   ;
  return _builder.getDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setBool(bool value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::BOOL);
  _builder.setDataField<bool>(
      ::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isInt8() const {
  return which() == Value::INT8;
}
inline bool Value::Builder::isInt8() {
  return which() == Value::INT8;
}
inline ::int8_t Value::Reader::getInt8() const {

                                                                   ;
  return _reader.getDataField< ::int8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::int8_t Value::Builder::getInt8() {

                                                                   ;
  return _builder.getDataField< ::int8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setInt8( ::int8_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::INT8);
  _builder.setDataField< ::int8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isInt16() const {
  return which() == Value::INT16;
}
inline bool Value::Builder::isInt16() {
  return which() == Value::INT16;
}
inline ::int16_t Value::Reader::getInt16() const {

                                                                   ;
  return _reader.getDataField< ::int16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::int16_t Value::Builder::getInt16() {

                                                                   ;
  return _builder.getDataField< ::int16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setInt16( ::int16_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::INT16);
  _builder.setDataField< ::int16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isInt32() const {
  return which() == Value::INT32;
}
inline bool Value::Builder::isInt32() {
  return which() == Value::INT32;
}
inline ::int32_t Value::Reader::getInt32() const {

                                                                   ;
  return _reader.getDataField< ::int32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::int32_t Value::Builder::getInt32() {

                                                                   ;
  return _builder.getDataField< ::int32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setInt32( ::int32_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::INT32);
  _builder.setDataField< ::int32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isInt64() const {
  return which() == Value::INT64;
}
inline bool Value::Builder::isInt64() {
  return which() == Value::INT64;
}
inline ::int64_t Value::Reader::getInt64() const {

                                                                   ;
  return _reader.getDataField< ::int64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::int64_t Value::Builder::getInt64() {

                                                                   ;
  return _builder.getDataField< ::int64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setInt64( ::int64_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::INT64);
  _builder.setDataField< ::int64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isUint8() const {
  return which() == Value::UINT8;
}
inline bool Value::Builder::isUint8() {
  return which() == Value::UINT8;
}
inline ::uint8_t Value::Reader::getUint8() const {

                                                                   ;
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint8_t Value::Builder::getUint8() {

                                                                   ;
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setUint8( ::uint8_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::UINT8);
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isUint16() const {
  return which() == Value::UINT16;
}
inline bool Value::Builder::isUint16() {
  return which() == Value::UINT16;
}
inline ::uint16_t Value::Reader::getUint16() const {

                                                                   ;
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Value::Builder::getUint16() {

                                                                   ;
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setUint16( ::uint16_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::UINT16);
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isUint32() const {
  return which() == Value::UINT32;
}
inline bool Value::Builder::isUint32() {
  return which() == Value::UINT32;
}
inline ::uint32_t Value::Reader::getUint32() const {

                                                                   ;
  return _reader.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint32_t Value::Builder::getUint32() {

                                                                   ;
  return _builder.getDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setUint32( ::uint32_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::UINT32);
  _builder.setDataField< ::uint32_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isUint64() const {
  return which() == Value::UINT64;
}
inline bool Value::Builder::isUint64() {
  return which() == Value::UINT64;
}
inline ::uint64_t Value::Reader::getUint64() const {

                                                                   ;
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Value::Builder::getUint64() {

                                                                   ;
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setUint64( ::uint64_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::UINT64);
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isFloat32() const {
  return which() == Value::FLOAT32;
}
inline bool Value::Builder::isFloat32() {
  return which() == Value::FLOAT32;
}
inline float Value::Reader::getFloat32() const {

                                                                   ;
  return _reader.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline float Value::Builder::getFloat32() {

                                                                   ;
  return _builder.getDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setFloat32(float value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::FLOAT32);
  _builder.setDataField<float>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isFloat64() const {
  return which() == Value::FLOAT64;
}
inline bool Value::Builder::isFloat64() {
  return which() == Value::FLOAT64;
}
inline double Value::Reader::getFloat64() const {

                                                                   ;
  return _reader.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline double Value::Builder::getFloat64() {

                                                                   ;
  return _builder.getDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setFloat64(double value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::FLOAT64);
  _builder.setDataField<double>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isText() const {
  return which() == Value::TEXT;
}
inline bool Value::Builder::isText() {
  return which() == Value::TEXT;
}
inline bool Value::Reader::hasText() const {
  if (which() != Value::TEXT) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Builder::hasText() {
  if (which() != Value::TEXT) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Value::Reader::getText() const {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Value::Builder::getText() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Value::Builder::setText( ::capnp::Text::Reader value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::TEXT);
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Value::Builder::initText(unsigned int size) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::TEXT);
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Value::Builder::adoptText(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::TEXT);
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> Value::Builder::disownText() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool Value::Reader::isData() const {
  return which() == Value::DATA;
}
inline bool Value::Builder::isData() {
  return which() == Value::DATA;
}
inline bool Value::Reader::hasData() const {
  if (which() != Value::DATA) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Builder::hasData() {
  if (which() != Value::DATA) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Data::Reader Value::Reader::getData() const {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Data::Builder Value::Builder::getData() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Value::Builder::setData( ::capnp::Data::Reader value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::DATA);
  ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Data::Builder Value::Builder::initData(unsigned int size) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::DATA);
  return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Value::Builder::adoptData(
    ::capnp::Orphan< ::capnp::Data>&& value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::DATA);
  ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Data> Value::Builder::disownData() {

                                                                   ;
  return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool Value::Reader::isList() const {
  return which() == Value::LIST;
}
inline bool Value::Builder::isList() {
  return which() == Value::LIST;
}
inline bool Value::Reader::hasList() const {
  if (which() != Value::LIST) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Builder::hasList() {
  if (which() != Value::LIST) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::AnyPointer::Reader Value::Reader::getList() const {

                                                                   ;
  return ::capnp::AnyPointer::Reader(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder Value::Builder::getList() {

                                                                   ;
  return ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder Value::Builder::initList() {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::LIST);
  auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
  result.clear();
  return result;
}

inline bool Value::Reader::isEnum() const {
  return which() == Value::ENUM;
}
inline bool Value::Builder::isEnum() {
  return which() == Value::ENUM;
}
inline ::uint16_t Value::Reader::getEnum() const {

                                                                   ;
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}

inline ::uint16_t Value::Builder::getEnum() {

                                                                   ;
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setEnum( ::uint16_t value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::ENUM);
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isStruct() const {
  return which() == Value::STRUCT;
}
inline bool Value::Builder::isStruct() {
  return which() == Value::STRUCT;
}
inline bool Value::Reader::hasStruct() const {
  if (which() != Value::STRUCT) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Builder::hasStruct() {
  if (which() != Value::STRUCT) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::AnyPointer::Reader Value::Reader::getStruct() const {

                                                                   ;
  return ::capnp::AnyPointer::Reader(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder Value::Builder::getStruct() {

                                                                   ;
  return ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder Value::Builder::initStruct() {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::STRUCT);
  auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
  result.clear();
  return result;
}

inline bool Value::Reader::isInterface() const {
  return which() == Value::INTERFACE;
}
inline bool Value::Builder::isInterface() {
  return which() == Value::INTERFACE;
}
inline ::capnp::Void Value::Reader::getInterface() const {

                                                                   ;
  return _reader.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::capnp::Void Value::Builder::getInterface() {

                                                                   ;
  return _builder.getDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Value::Builder::setInterface( ::capnp::Void value) {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::INTERFACE);
  _builder.setDataField< ::capnp::Void>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Value::Reader::isAnyPointer() const {
  return which() == Value::ANY_POINTER;
}
inline bool Value::Builder::isAnyPointer() {
  return which() == Value::ANY_POINTER;
}
inline bool Value::Reader::hasAnyPointer() const {
  if (which() != Value::ANY_POINTER) return false;
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Builder::hasAnyPointer() {
  if (which() != Value::ANY_POINTER) return false;
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::AnyPointer::Reader Value::Reader::getAnyPointer() const {

                                                                   ;
  return ::capnp::AnyPointer::Reader(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder Value::Builder::getAnyPointer() {

                                                                   ;
  return ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::AnyPointer::Builder Value::Builder::initAnyPointer() {
  _builder.setDataField<Value::Which>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::ANY_POINTER);
  auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
  result.clear();
  return result;
}

inline ::uint64_t Annotation::Reader::getId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t Annotation::Builder::getId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void Annotation::Builder::setId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool Annotation::Reader::hasValue() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Annotation::Builder::hasValue() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Value::Reader Annotation::Reader::getValue() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Value::Builder Annotation::Builder::getValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Value::Pipeline Annotation::Pipeline::getValue() {
  return ::capnp::schema::Value::Pipeline(_typeless.getPointerField(0));
}

inline void Annotation::Builder::setValue( ::capnp::schema::Value::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Value>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Value::Builder Annotation::Builder::initValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Annotation::Builder::adoptValue(
    ::capnp::Orphan< ::capnp::schema::Value>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Value>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Value> Annotation::Builder::disownValue() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Value>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool Annotation::Reader::hasBrand() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool Annotation::Builder::hasBrand() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::Brand::Reader Annotation::Reader::getBrand() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::schema::Brand::Builder Annotation::Builder::getBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline ::capnp::schema::Brand::Pipeline Annotation::Pipeline::getBrand() {
  return ::capnp::schema::Brand::Pipeline(_typeless.getPointerField(1));
}

inline void Annotation::Builder::setBrand( ::capnp::schema::Brand::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::Brand::Builder Annotation::Builder::initBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Annotation::Builder::adoptBrand(
    ::capnp::Orphan< ::capnp::schema::Brand>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::Brand> Annotation::Builder::disownBrand() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::Brand>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline ::uint16_t CapnpVersion::Reader::getMajor() const {
  return _reader.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint16_t CapnpVersion::Builder::getMajor() {
  return _builder.getDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void CapnpVersion::Builder::setMajor( ::uint16_t value) {
  _builder.setDataField< ::uint16_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline ::uint8_t CapnpVersion::Reader::getMinor() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}

inline ::uint8_t CapnpVersion::Builder::getMinor() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS);
}
inline void CapnpVersion::Builder::setMinor( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
}

inline ::uint8_t CapnpVersion::Reader::getMicro() const {
  return _reader.getDataField< ::uint8_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}

inline ::uint8_t CapnpVersion::Builder::getMicro() {
  return _builder.getDataField< ::uint8_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS);
}
inline void CapnpVersion::Builder::setMicro( ::uint8_t value) {
  _builder.setDataField< ::uint8_t>(
      ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
}

inline bool CodeGeneratorRequest::Reader::hasNodes() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool CodeGeneratorRequest::Builder::hasNodes() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::Node>::Reader CodeGeneratorRequest::Reader::getNodes() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node>>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::Node>::Builder CodeGeneratorRequest::Builder::getNodes() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node>>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void CodeGeneratorRequest::Builder::setNodes( ::capnp::List< ::capnp::schema::Node>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node>>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::Node>::Builder CodeGeneratorRequest::Builder::initNodes(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node>>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void CodeGeneratorRequest::Builder::adoptNodes(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node>>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::Node>> CodeGeneratorRequest::Builder::disownNodes() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::Node>>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool CodeGeneratorRequest::Reader::hasRequestedFiles() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool CodeGeneratorRequest::Builder::hasRequestedFiles() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Reader CodeGeneratorRequest::Reader::getRequestedFiles() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Builder CodeGeneratorRequest::Builder::getRequestedFiles() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void CodeGeneratorRequest::Builder::setRequestedFiles( ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>::Builder CodeGeneratorRequest::Builder::initRequestedFiles(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void CodeGeneratorRequest::Builder::adoptRequestedFiles(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>> CodeGeneratorRequest::Builder::disownRequestedFiles() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline bool CodeGeneratorRequest::Reader::hasCapnpVersion() const {
  return !_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline bool CodeGeneratorRequest::Builder::hasCapnpVersion() {
  return !_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::schema::CapnpVersion::Reader CodeGeneratorRequest::Reader::getCapnpVersion() const {
  return ::capnp::_::PointerHelpers< ::capnp::schema::CapnpVersion>::get(_reader.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline ::capnp::schema::CapnpVersion::Builder CodeGeneratorRequest::Builder::getCapnpVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::CapnpVersion>::get(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline ::capnp::schema::CapnpVersion::Pipeline CodeGeneratorRequest::Pipeline::getCapnpVersion() {
  return ::capnp::schema::CapnpVersion::Pipeline(_typeless.getPointerField(2));
}

inline void CodeGeneratorRequest::Builder::setCapnpVersion( ::capnp::schema::CapnpVersion::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::CapnpVersion>::set(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), value);
}
inline ::capnp::schema::CapnpVersion::Builder CodeGeneratorRequest::Builder::initCapnpVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::CapnpVersion>::init(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}
inline void CodeGeneratorRequest::Builder::adoptCapnpVersion(
    ::capnp::Orphan< ::capnp::schema::CapnpVersion>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::schema::CapnpVersion>::adopt(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::schema::CapnpVersion> CodeGeneratorRequest::Builder::disownCapnpVersion() {
  return ::capnp::_::PointerHelpers< ::capnp::schema::CapnpVersion>::disown(_builder.getPointerField(
      ::capnp::bounded<2>() * ::capnp::POINTERS));
}

inline ::uint64_t CodeGeneratorRequest::RequestedFile::Reader::getId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t CodeGeneratorRequest::RequestedFile::Builder::getId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void CodeGeneratorRequest::RequestedFile::Builder::setId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool CodeGeneratorRequest::RequestedFile::Reader::hasFilename() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool CodeGeneratorRequest::RequestedFile::Builder::hasFilename() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader CodeGeneratorRequest::RequestedFile::Reader::getFilename() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder CodeGeneratorRequest::RequestedFile::Builder::getFilename() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void CodeGeneratorRequest::RequestedFile::Builder::setFilename( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder CodeGeneratorRequest::RequestedFile::Builder::initFilename(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void CodeGeneratorRequest::RequestedFile::Builder::adoptFilename(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> CodeGeneratorRequest::RequestedFile::Builder::disownFilename() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

inline bool CodeGeneratorRequest::RequestedFile::Reader::hasImports() const {
  return !_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool CodeGeneratorRequest::RequestedFile::Builder::hasImports() {
  return !_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Reader CodeGeneratorRequest::RequestedFile::Reader::getImports() const {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>::get(_reader.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Builder CodeGeneratorRequest::RequestedFile::Builder::getImports() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>::get(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void CodeGeneratorRequest::RequestedFile::Builder::setImports( ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>::set(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>::Builder CodeGeneratorRequest::RequestedFile::Builder::initImports(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>::init(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void CodeGeneratorRequest::RequestedFile::Builder::adoptImports(
    ::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>::adopt(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>> CodeGeneratorRequest::RequestedFile::Builder::disownImports() {
  return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::schema::CodeGeneratorRequest::RequestedFile::Import>>::disown(_builder.getPointerField(
      ::capnp::bounded<1>() * ::capnp::POINTERS));
}

inline ::uint64_t CodeGeneratorRequest::RequestedFile::Import::Reader::getId() const {
  return _reader.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}

inline ::uint64_t CodeGeneratorRequest::RequestedFile::Import::Builder::getId() {
  return _builder.getDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void CodeGeneratorRequest::RequestedFile::Import::Builder::setId( ::uint64_t value) {
  _builder.setDataField< ::uint64_t>(
      ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}

inline bool CodeGeneratorRequest::RequestedFile::Import::Reader::hasName() const {
  return !_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool CodeGeneratorRequest::RequestedFile::Import::Builder::hasName() {
  return !_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader CodeGeneratorRequest::RequestedFile::Import::Reader::getName() const {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder CodeGeneratorRequest::RequestedFile::Import::Builder::getName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void CodeGeneratorRequest::RequestedFile::Import::Builder::setName( ::capnp::Text::Reader value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder CodeGeneratorRequest::RequestedFile::Import::Builder::initName(unsigned int size) {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void CodeGeneratorRequest::RequestedFile::Import::Builder::adoptName(
    ::capnp::Orphan< ::capnp::Text>&& value) {
  ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> CodeGeneratorRequest::RequestedFile::Import::Builder::disownName() {
  return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
      ::capnp::bounded<0>() * ::capnp::POINTERS));
}

}
}
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 1
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h"
#define CAPNP_SERIALIZE_H_ 
# 46 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 1 3
# 24 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 3
#define KJ_MUTEX_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 3






#define KJ_USE_FUTEX 1








namespace kj {




namespace _ {

class Mutex {


public:
  Mutex();
  ~Mutex();
  Mutex(const Mutex&) = delete; Mutex& operator=(const Mutex&) = delete;

  enum Exclusivity {
    EXCLUSIVE,
    SHARED
  };

  void lock(Exclusivity exclusivity);
  void unlock(Exclusivity exclusivity);

  void assertLockedByCaller(Exclusivity exclusivity);




private:

  uint futex;






  static constexpr uint EXCLUSIVE_HELD = 1u << 31;
  static constexpr uint EXCLUSIVE_REQUESTED = 1u << 30;
  static constexpr uint SHARED_COUNT_MASK = EXCLUSIVE_REQUESTED - 1;







};

class Once {


public:

  inline Once(bool startInitialized = false)
      : futex(startInitialized ? INITIALIZED : UNINITIALIZED) {}




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

  class Initializer {
  public:
    virtual void run() = 0;
  };

  void runOnce(Initializer& init);





  inline bool isInitialized() noexcept {


    return __atomic_load_n(&futex, 2) == INITIALIZED;



  }


  void reset();




private:

  uint futex;

  enum State {
    UNINITIALIZED,
    INITIALIZING,
    INITIALIZING_WITH_WAITERS,
    INITIALIZED
  };
# 152 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 3
};

}




template <typename T>
class Locked {



public:
  Locked(const Locked&) = delete; Locked& operator=(const Locked&) = delete;
  inline Locked(): mutex(nullptr), ptr(nullptr) {}
  inline Locked(Locked&& other): mutex(other.mutex), ptr(other.ptr) {
    other.mutex = nullptr;
    other.ptr = nullptr;
  }
  inline ~Locked() {
    if (mutex != nullptr) mutex->unlock(isConst<T>() ? _::Mutex::SHARED : _::Mutex::EXCLUSIVE);
  }

  inline Locked& operator=(Locked&& other) {
    if (mutex != nullptr) mutex->unlock(isConst<T>() ? _::Mutex::SHARED : _::Mutex::EXCLUSIVE);
    mutex = other.mutex;
    ptr = other.ptr;
    other.mutex = nullptr;
    other.ptr = nullptr;
    return *this;
  }

  inline void release() {
    if (mutex != nullptr) mutex->unlock(isConst<T>() ? _::Mutex::SHARED : _::Mutex::EXCLUSIVE);
    mutex = nullptr;
    ptr = nullptr;
  }

  inline T* operator->() { return ptr; }
  inline const T* operator->() const { return ptr; }
  inline T& operator*() { return *ptr; }
  inline const T& operator*() const { return *ptr; }
  inline T* get() { return ptr; }
  inline const T* get() const { return ptr; }
  inline operator T*() { return ptr; }
  inline operator const T*() const { return ptr; }

private:
  _::Mutex* mutex;
  T* ptr;

  inline Locked(_::Mutex& mutex, T& value): mutex(&mutex), ptr(&value) {}

  template <typename U>
  friend class MutexGuarded;
};

template <typename T>
class MutexGuarded {
# 223 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 3
public:
  template <typename... Params>
  explicit MutexGuarded(Params&&... params);


  Locked<T> lockExclusive() const;
# 238 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 3
  Locked<const T> lockShared() const;



  inline const T& getWithoutLock() const { return value; }
  inline T& getWithoutLock() { return value; }



  inline const T& getAlreadyLockedShared() const;
  inline T& getAlreadyLockedShared();
  inline T& getAlreadyLockedExclusive() const;


private:
  mutable _::Mutex mutex;
  mutable T value;
};

template <typename T>
class MutexGuarded<const T> {


  static_assert(sizeof(T) < 0, "MutexGuarded's type cannot be const.");
};

template <typename T>
class Lazy {


public:
  template <typename Func>
  T& get(Func&& init);
  template <typename Func>
  const T& get(Func&& init) const;
# 281 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/mutex.h" 3
private:
  mutable _::Once once;
  mutable SpaceFor<T> space;
  mutable Own<T> value;

  template <typename Func>
  class InitImpl;
};




template <typename T>
template <typename... Params>
inline MutexGuarded<T>::MutexGuarded(Params&&... params)
    : value(kj::fwd<Params>(params)...) {}

template <typename T>
inline Locked<T> MutexGuarded<T>::lockExclusive() const {
  mutex.lock(_::Mutex::EXCLUSIVE);
  return Locked<T>(mutex, value);
}

template <typename T>
inline Locked<const T> MutexGuarded<T>::lockShared() const {
  mutex.lock(_::Mutex::SHARED);
  return Locked<const T>(mutex, value);
}

template <typename T>
inline const T& MutexGuarded<T>::getAlreadyLockedShared() const {



  return value;
}
template <typename T>
inline T& MutexGuarded<T>::getAlreadyLockedShared() {



  return value;
}
template <typename T>
inline T& MutexGuarded<T>::getAlreadyLockedExclusive() const {



  return const_cast<T&>(value);
}

template <typename T>
template <typename Func>
class Lazy<T>::InitImpl: public _::Once::Initializer {
public:
  inline InitImpl(const Lazy<T>& lazy, Func&& func): lazy(lazy), func(kj::fwd<Func>(func)) {}

  void run() override {
    lazy.value = func(lazy.space);
  }

private:
  const Lazy<T>& lazy;
  Func func;
};

template <typename T>
template <typename Func>
inline T& Lazy<T>::get(Func&& init) {
  if (!once.isInitialized()) {
    InitImpl<Func> initImpl(*this, kj::fwd<Func>(init));
    once.runOnce(initImpl);
  }
  return *value;
}

template <typename T>
template <typename Func>
inline const T& Lazy<T>::get(Func&& init) const {
  if (!once.isInitialized()) {
    InitImpl<Func> initImpl(*this, kj::fwd<Func>(init));
    once.runOnce(initImpl);
  }
  return *value;
}

}
# 25 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 1 3
# 108 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
#define KJ_DEBUG_H_ 
# 112 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/exception.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/exception.h" 3
#define KJ_EXCEPTION_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/exception.h" 3






namespace kj {

class ExceptionImpl;

class Exception {





public:
  enum class Type {


    FAILED = 0,



    OVERLOADED = 1,







    DISCONNECTED = 2,



    UNIMPLEMENTED = 3






  };

  Exception(Type type, const char* file, int line, String description = nullptr) noexcept;
  Exception(Type type, String file, int line, String description = nullptr) noexcept;
  Exception(const Exception& other) noexcept;
  Exception(Exception&& other) = default;
  ~Exception() noexcept;

  const char* getFile() const { return file; }
  int getLine() const { return line; }
  Type getType() const { return type; }
  StringPtr getDescription() const { return description; }
  ArrayPtr<void* const> getStackTrace() const { return arrayPtr(trace, traceCount); }

  struct Context {


    const char* file;
    int line;
    String description;
    Maybe<Own<Context>> next;

    Context(const char* file, int line, String&& description, Maybe<Own<Context>>&& next)
        : file(file), line(line), description(mv(description)), next(mv(next)) {}
    Context(const Context& other) noexcept;
  };

  inline Maybe<const Context&> getContext() const {
    if (auto c = ::kj::_::readMaybe(context)) {
      return **c;
    } else {
      return nullptr;
    }
  }

  void wrapContext(const char* file, int line, String&& description);




  __attribute__((noinline)) void extendTrace(uint ignoreCount);



  __attribute__((noinline)) void truncateCommonTrace();




  void addTrace(void* ptr);



private:
  String ownFile;
  const char* file;
  int line;
  Type type;
  String description;
  Maybe<Own<Context>> context;
  void* trace[32];
  uint traceCount;

  friend class ExceptionImpl;
};

StringPtr operator*(::kj::_::Stringifier, Exception::Type type);
String operator*(::kj::_::Stringifier, const Exception& e);



enum class LogSeverity {
  INFO,


  WARNING,
  ERROR,
  FATAL,
  DBG


};

StringPtr operator*(::kj::_::Stringifier, LogSeverity severity);

class ExceptionCallback {
# 168 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/exception.h" 3
public:
  ExceptionCallback();
  ExceptionCallback(const ExceptionCallback&) = delete; ExceptionCallback& operator=(const ExceptionCallback&) = delete;
  virtual ~ExceptionCallback() noexcept(false);

  virtual void onRecoverableException(Exception&& exception);







  virtual void onFatalException(Exception&& exception);







  virtual void logMessage(LogSeverity severity, const char* file, int line, int contextDepth,
                          String&& text);





  enum class StackTraceMode {
    FULL,





    ADDRESS_ONLY,




    NONE





  };

  virtual StackTraceMode stackTraceMode();


protected:
  ExceptionCallback& next;

private:
  ExceptionCallback(ExceptionCallback& next);

  class RootExceptionCallback;
  friend ExceptionCallback& getExceptionCallback();
};

ExceptionCallback& getExceptionCallback();


__attribute__((noinline)) void throwFatalException(kj::Exception&& exception, uint ignoreCount = 0) __attribute__((noreturn));



__attribute__((noinline)) void throwRecoverableException(kj::Exception&& exception, uint ignoreCount = 0);





namespace _ { class Runnable; }

template <typename Func>
Maybe<Exception> runCatchingExceptions(Func&& func) noexcept;







class UnwindDetector {
# 263 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/exception.h" 3
public:
  UnwindDetector();

  bool isUnwinding() const;



  template <typename Func>
  void catchExceptionsIfUnwinding(Func&& func) const;




private:
  uint uncaughtCount;

  void catchExceptionsAsSecondaryFaults(_::Runnable& runnable) const;
};

namespace _ {

class Runnable {
public:
  virtual void run() = 0;
};

template <typename Func>
class RunnableImpl: public Runnable {
public:
  RunnableImpl(Func&& func): func(kj::mv(func)) {}
  void run() override {
    func();
  }
private:
  Func func;
};

Maybe<Exception> runCatchingExceptions(Runnable& runnable) noexcept;

}

template <typename Func>
Maybe<Exception> runCatchingExceptions(Func&& func) noexcept {
  _::RunnableImpl<Decay<Func>> runnable(kj::fwd<Func>(func));
  return _::runCatchingExceptions(runnable);
}

template <typename Func>
void UnwindDetector::catchExceptionsIfUnwinding(Func&& func) const {
  if (isUnwinding()) {
    _::RunnableImpl<Decay<Func>> runnable(kj::fwd<Func>(func));
    catchExceptionsAsSecondaryFaults(runnable);
  } else {
    func();
  }
}

#define KJ_ON_SCOPE_SUCCESS(code) ::kj::UnwindDetector KJ_UNIQUE_NAME(_kjUnwindDetector); KJ_DEFER(if (!KJ_UNIQUE_NAME(_kjUnwindDetector).isUnwinding()) { code; })




#define KJ_ON_SCOPE_FAILURE(code) ::kj::UnwindDetector KJ_UNIQUE_NAME(_kjUnwindDetector); KJ_DEFER(if (KJ_UNIQUE_NAME(_kjUnwindDetector).isUnwinding()) { code; })






__attribute__((noinline)) ArrayPtr<void* const> getStackTrace(ArrayPtr<void*> space, uint ignoreCount);
# 345 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/exception.h" 3
String stringifyStackTrace(ArrayPtr<void* const>);



String getStackTrace();


void printStackTraceOnCrash();




kj::StringPtr trimSourceFilename(kj::StringPtr filename);



}
# 116 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 2 3






namespace kj {
# 217 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
#define KJ_LOG(severity,...) if (!::kj::_::Debug::shouldLog(::kj::LogSeverity::severity)) {} else ::kj::_::Debug::log(__FILE__, __LINE__, ::kj::LogSeverity::severity, #__VA_ARGS__, ##__VA_ARGS__)




#define KJ_DBG(...) KJ_LOG(DBG, ##__VA_ARGS__)

#define KJ_REQUIRE(cond,...) if (KJ_LIKELY(cond)) {} else for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, #cond, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())




#define KJ_FAIL_REQUIRE(...) for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, nullptr, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())



#define KJ_SYSCALL(call,...) if (auto _kjSyscallResult = ::kj::_::Debug::syscall([&](){return (call);}, false)) {} else for (::kj::_::Debug::Fault f(__FILE__, __LINE__, _kjSyscallResult.getErrorNumber(), #call, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())




#define KJ_NONBLOCKING_SYSCALL(call,...) if (auto _kjSyscallResult = ::kj::_::Debug::syscall([&](){return (call);}, true)) {} else for (::kj::_::Debug::Fault f(__FILE__, __LINE__, _kjSyscallResult.getErrorNumber(), #call, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())




#define KJ_FAIL_SYSCALL(code,errorNumber,...) for (::kj::_::Debug::Fault f(__FILE__, __LINE__, errorNumber, code, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())
# 265 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
#define KJ_UNIMPLEMENTED(...) for (::kj::_::Debug::Fault f(__FILE__, __LINE__, ::kj::Exception::Type::UNIMPLEMENTED, nullptr, #__VA_ARGS__, ##__VA_ARGS__);; f.fatal())



#define KJ_CONTEXT(...) auto KJ_UNIQUE_NAME(_kjContextFunc) = [&]() -> ::kj::_::Debug::Context::Value { return ::kj::_::Debug::Context::Value(__FILE__, __LINE__, ::kj::_::Debug::makeDescription(#__VA_ARGS__, ##__VA_ARGS__)); }; ::kj::_::Debug::ContextImpl<decltype(KJ_UNIQUE_NAME(_kjContextFunc))> KJ_UNIQUE_NAME(_kjContext)(KJ_UNIQUE_NAME(_kjContextFunc))







#define KJ_REQUIRE_NONNULL(value,...) (*({ auto _kj_result = ::kj::_::readMaybe(value); if (KJ_UNLIKELY(!_kj_result)) { ::kj::_::Debug::Fault(__FILE__, __LINE__, ::kj::Exception::Type::FAILED, #value " != nullptr", #__VA_ARGS__, ##__VA_ARGS__).fatal(); } kj::mv(_kj_result); }))
# 287 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
#define KJ_EXCEPTION(type,...) ::kj::Exception(::kj::Exception::Type::type, __FILE__, __LINE__, ::kj::_::Debug::makeDescription(#__VA_ARGS__, ##__VA_ARGS__))





#define KJ_SYSCALL_HANDLE_ERRORS(call) if (int _kjSyscallError = ::kj::_::Debug::syscallError([&](){return (call);}, false)) switch (int error = _kjSyscallError)
# 312 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
#define KJ_ASSERT KJ_REQUIRE
#define KJ_FAIL_ASSERT KJ_FAIL_REQUIRE
#define KJ_ASSERT_NONNULL KJ_REQUIRE_NONNULL
# 323 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
#define KJ_DLOG(...) do {} while (false)
#define KJ_DASSERT(...) do {} while (false)
#define KJ_DREQUIRE(...) do {} while (false)


namespace _ {

class Debug {
public:
  Debug() = delete;

  typedef LogSeverity Severity;
# 344 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
  static inline bool shouldLog(LogSeverity severity) { return severity >= minSeverity; }


  static inline void setLogLevel(LogSeverity severity) { minSeverity = severity; }




  template <typename... Params>
  static void log(const char* file, int line, LogSeverity severity, const char* macroArgs,
                  Params&&... params);

  class Fault {
  public:
    template <typename Code, typename... Params>
    Fault(const char* file, int line, Code code,
          const char* condition, const char* macroArgs, Params&&... params);
    Fault(const char* file, int line, Exception::Type type,
          const char* condition, const char* macroArgs);
    Fault(const char* file, int line, int osErrorNumber,
          const char* condition, const char* macroArgs);




    ~Fault() noexcept(false);

    __attribute__((noinline)) void fatal() __attribute__((noreturn));


  private:
    void init(const char* file, int line, Exception::Type type,
              const char* condition, const char* macroArgs, ArrayPtr<String> argValues);
    void init(const char* file, int line, int osErrorNumber,
              const char* condition, const char* macroArgs, ArrayPtr<String> argValues);





    Exception* exception;
  };

  class SyscallResult {
  public:
    inline SyscallResult(int errorNumber): errorNumber(errorNumber) {}
    inline operator void*() { return errorNumber == 0 ? this : nullptr; }
    inline int getErrorNumber() { return errorNumber; }

  private:
    int errorNumber;
  };

  template <typename Call>
  static SyscallResult syscall(Call&& call, bool nonblocking);
  template <typename Call>
  static int syscallError(Call&& call, bool nonblocking);







  class Context: public ExceptionCallback {
  public:
    Context();
    Context(const Context&) = delete; Context& operator=(const Context&) = delete;
    virtual ~Context() noexcept(false);

    struct Value {
      const char* file;
      int line;
      String description;

      inline Value(const char* file, int line, String&& description)
          : file(file), line(line), description(mv(description)) {}
    };

    virtual Value evaluate() = 0;

    virtual void onRecoverableException(Exception&& exception) override;
    virtual void onFatalException(Exception&& exception) override;
    virtual void logMessage(LogSeverity severity, const char* file, int line, int contextDepth,
                            String&& text) override;

  private:
    bool logged;
    Maybe<Value> value;

    Value ensureInitialized();
  };

  template <typename Func>
  class ContextImpl: public Context {
  public:
    inline ContextImpl(Func& func): func(func) {}
    ContextImpl(const ContextImpl&) = delete; ContextImpl& operator=(const ContextImpl&) = delete;

    Value evaluate() override {
      return func();
    }
  private:
    Func& func;
  };

  template <typename... Params>
  static String makeDescription(const char* macroArgs, Params&&... params);

private:
  static LogSeverity minSeverity;

  static void logInternal(const char* file, int line, LogSeverity severity, const char* macroArgs,
                          ArrayPtr<String> argValues);
  static String makeDescriptionInternal(const char* macroArgs, ArrayPtr<String> argValues);

  static int getOsErrorNumber(bool nonblocking);

};

template <typename... Params>
void Debug::log(const char* file, int line, LogSeverity severity, const char* macroArgs,
                Params&&... params) {
  String argValues[sizeof...(Params)] = {str(params)...};
  logInternal(file, line, severity, macroArgs, arrayPtr(argValues, sizeof...(Params)));
}

template <>
inline void Debug::log<>(const char* file, int line, LogSeverity severity, const char* macroArgs) {
  logInternal(file, line, severity, macroArgs, nullptr);
}

template <typename Code, typename... Params>
Debug::Fault::Fault(const char* file, int line, Code code,
                    const char* condition, const char* macroArgs, Params&&... params)
    : exception(nullptr) {
  String argValues[sizeof...(Params)] = {str(params)...};
  init(file, line, code, condition, macroArgs,
       arrayPtr(argValues, sizeof...(Params)));
}

inline Debug::Fault::Fault(const char* file, int line, int osErrorNumber,
                           const char* condition, const char* macroArgs)
    : exception(nullptr) {
  init(file, line, osErrorNumber, condition, macroArgs, nullptr);
}

inline Debug::Fault::Fault(const char* file, int line, kj::Exception::Type type,
                           const char* condition, const char* macroArgs)
    : exception(nullptr) {
  init(file, line, type, condition, macroArgs, nullptr);
}
# 513 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/debug.h" 3
template <typename Call>
Debug::SyscallResult Debug::syscall(Call&& call, bool nonblocking) {
  while (call() < 0) {
    int errorNum = getOsErrorNumber(nonblocking);



    if (errorNum != -1) {
      return SyscallResult(errorNum);
    }
  }
  return SyscallResult(0);
}

template <typename Call>
int Debug::syscallError(Call&& call, bool nonblocking) {
  while (call() < 0) {
    int errorNum = getOsErrorNumber(nonblocking);



    if (errorNum != -1) {
      return errorNum;
    }
  }
  return 0;
}

template <typename... Params>
String Debug::makeDescription(const char* macroArgs, Params&&... params) {
  String argValues[sizeof...(Params)] = {str(params)...};
  return makeDescriptionInternal(macroArgs, arrayPtr(argValues, sizeof...(Params)));
}

template <>
inline String Debug::makeDescription<>(const char* macroArgs) {
  return makeDescriptionInternal(macroArgs, nullptr);
}

}
}
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 2 3





#define CAPNP_MESSAGE_H_ 
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3


namespace capnp {

namespace _ {
  class ReaderArena;
  class BuilderArena;
}

class StructSchema;
class Orphanage;
template <typename T>
class Orphan;



struct ReaderOptions {


  uint64_t traversalLimitInWords = 8 * 1024 * 1024;
# 75 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
  int nestingLimit = 64;
# 84 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
};

class MessageReader {
# 97 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
public:
  MessageReader(ReaderOptions options);




  virtual ~MessageReader() noexcept(false);

  virtual kj::ArrayPtr<const word> getSegment(uint id) = 0;



  inline const ReaderOptions& getOptions();


  template <typename RootType>
  typename RootType::Reader getRoot();


  template <typename RootType, typename SchemaType>
  typename RootType::Reader getRoot(SchemaType schema);




  bool isCanonical();


private:
  ReaderOptions options;





  void* arenaSpace[15 + sizeof(kj::MutexGuarded<void*>) / sizeof(void*)];
  bool allocatedArena;

  _::ReaderArena* arena() { return reinterpret_cast<_::ReaderArena*>(arenaSpace); }
  AnyPointer::Reader getRootInternal();
};

class MessageBuilder {
# 151 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
public:
  MessageBuilder();
  virtual ~MessageBuilder() noexcept(false);
  MessageBuilder(const MessageBuilder&) = delete; MessageBuilder& operator=(const MessageBuilder&) = delete;

  struct SegmentInit {
    kj::ArrayPtr<word> space;

    size_t wordsUsed;


  };

  explicit MessageBuilder(kj::ArrayPtr<SegmentInit> segments);
# 185 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
  virtual kj::ArrayPtr<word> allocateSegment(uint minimumSize) = 0;
# 194 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
  template <typename RootType>
  typename RootType::Builder initRoot();


  template <typename Reader>
  void setRoot(Reader&& value);


  template <typename RootType>
  typename RootType::Builder getRoot();


  template <typename RootType, typename SchemaType>
  typename RootType::Builder getRoot(SchemaType schema);




  template <typename RootType, typename SchemaType>
  typename RootType::Builder initRoot(SchemaType schema);




  template <typename T>
  void adoptRoot(Orphan<T>&& orphan);


  kj::ArrayPtr<const kj::ArrayPtr<const word>> getSegmentsForOutput();


  Orphanage getOrphanage();

  bool isCanonical();


private:
  void* arenaSpace[22];





  bool allocatedArena = false;






  _::BuilderArena* arena() { return reinterpret_cast<_::BuilderArena*>(arenaSpace); }
  _::SegmentBuilder* getRootSegment();
  AnyPointer::Builder getRootInternal();
};

template <typename RootType>
typename RootType::Reader readMessageUnchecked(const word* data);
# 275 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
template <typename Reader>
void copyToUnchecked(Reader&& reader, kj::ArrayPtr<word> uncheckedBuffer);




template <typename RootType>
typename RootType::Reader readDataStruct(kj::ArrayPtr<const word> data);
# 295 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
template <typename BuilderType>
typename kj::ArrayPtr<const word> writeDataStruct(BuilderType builder);





template <typename Type>
static typename Type::Reader defaultValue();






class SegmentArrayMessageReader: public MessageReader {




public:
  SegmentArrayMessageReader(kj::ArrayPtr<const kj::ArrayPtr<const word>> segments,
                            ReaderOptions options = ReaderOptions());



  SegmentArrayMessageReader(const SegmentArrayMessageReader&) = delete; SegmentArrayMessageReader& operator=(const SegmentArrayMessageReader&) = delete;
  ~SegmentArrayMessageReader() noexcept(false);

  virtual kj::ArrayPtr<const word> getSegment(uint id) override;

private:
  kj::ArrayPtr<const kj::ArrayPtr<const word>> segments;
};

enum class AllocationStrategy: uint8_t {
  FIXED_SIZE,







  GROW_HEURISTICALLY




};

constexpr uint SUGGESTED_FIRST_SEGMENT_WORDS = 1024;
constexpr AllocationStrategy SUGGESTED_ALLOCATION_STRATEGY = AllocationStrategy::GROW_HEURISTICALLY;

class MallocMessageBuilder: public MessageBuilder {




public:
  explicit MallocMessageBuilder(uint firstSegmentWords = SUGGESTED_FIRST_SEGMENT_WORDS,
      AllocationStrategy allocationStrategy = SUGGESTED_ALLOCATION_STRATEGY);
# 369 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
  explicit MallocMessageBuilder(kj::ArrayPtr<word> firstSegment,
      AllocationStrategy allocationStrategy = SUGGESTED_ALLOCATION_STRATEGY);







  MallocMessageBuilder(const MallocMessageBuilder&) = delete; MallocMessageBuilder& operator=(const MallocMessageBuilder&) = delete;
  virtual ~MallocMessageBuilder() noexcept(false);

  virtual kj::ArrayPtr<word> allocateSegment(uint minimumSize) override;

private:
  uint nextSize;
  AllocationStrategy allocationStrategy;

  bool ownFirstSegment;
  bool returnedFirstSegment;

  void* firstSegment;

  struct MoreSegments;
  kj::Maybe<kj::Own<MoreSegments>> moreSegments;
};

class FlatMessageBuilder: public MessageBuilder {
# 409 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 3
public:
  explicit FlatMessageBuilder(kj::ArrayPtr<word> array);
  FlatMessageBuilder(const FlatMessageBuilder&) = delete; FlatMessageBuilder& operator=(const FlatMessageBuilder&) = delete;
  virtual ~FlatMessageBuilder() noexcept(false);

  void requireFilled();


  virtual kj::ArrayPtr<word> allocateSegment(uint minimumSize) override;

private:
  kj::ArrayPtr<word> array;
  bool allocated;
};




inline const ReaderOptions& MessageReader::getOptions() {
  return options;
}

template <typename RootType>
inline typename RootType::Reader MessageReader::getRoot() {
  return getRootInternal().getAs<RootType>();
}

template <typename RootType>
inline typename RootType::Builder MessageBuilder::initRoot() {
  return getRootInternal().initAs<RootType>();
}

template <typename Reader>
inline void MessageBuilder::setRoot(Reader&& value) {
  getRootInternal().setAs<FromReader<Reader>>(value);
}

template <typename RootType>
inline typename RootType::Builder MessageBuilder::getRoot() {
  return getRootInternal().getAs<RootType>();
}

template <typename T>
void MessageBuilder::adoptRoot(Orphan<T>&& orphan) {
  return getRootInternal().adopt(kj::mv(orphan));
}

template <typename RootType, typename SchemaType>
typename RootType::Reader MessageReader::getRoot(SchemaType schema) {
  return getRootInternal().getAs<RootType>(schema);
}

template <typename RootType, typename SchemaType>
typename RootType::Builder MessageBuilder::getRoot(SchemaType schema) {
  return getRootInternal().getAs<RootType>(schema);
}

template <typename RootType, typename SchemaType>
typename RootType::Builder MessageBuilder::initRoot(SchemaType schema) {
  return getRootInternal().initAs<RootType>(schema);
}

template <typename RootType>
typename RootType::Reader readMessageUnchecked(const word* data) {
  return AnyPointer::Reader(_::PointerReader::getRootUnchecked(data)).getAs<RootType>();
}

template <typename Reader>
void copyToUnchecked(Reader&& reader, kj::ArrayPtr<word> uncheckedBuffer) {
  FlatMessageBuilder builder(uncheckedBuffer);
  builder.setRoot(kj::fwd<Reader>(reader));
  builder.requireFilled();
}

template <typename RootType>
typename RootType::Reader readDataStruct(kj::ArrayPtr<const word> data) {
  return typename RootType::Reader(_::StructReader(data));
}

template <typename BuilderType>
typename kj::ArrayPtr<const word> writeDataStruct(BuilderType builder) {
  auto bytes = _::PointerHelpers<FromBuilder<BuilderType>>::getInternalBuilder(kj::mv(builder))
      .getDataSectionAsBlob();
  return kj::arrayPtr(reinterpret_cast<word*>(bytes.begin()),
                      reinterpret_cast<word*>(bytes.end()));
}

template <typename Type>
static typename Type::Reader defaultValue() {
  return typename Type::Reader(_::StructReader());
}

template <typename T>
kj::Array<word> canonicalize(T&& reader) {
    return _::PointerHelpers<FromReader<T>>::getInternalReader(reader).canonicalize();
}

}
# 49 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 3
#define KJ_IO_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 2 3




namespace kj {




class InputStream {
public:
  virtual ~InputStream() noexcept(false);

  size_t read(void* buffer, size_t minBytes, size_t maxBytes);
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 3
  virtual size_t tryRead(void* buffer, size_t minBytes, size_t maxBytes) = 0;


  inline void read(void* buffer, size_t bytes) { read(buffer, bytes, bytes); }


  virtual void skip(size_t bytes);


};

class OutputStream {
public:
  virtual ~OutputStream() noexcept(false);

  virtual void write(const void* buffer, size_t size) = 0;


  virtual void write(ArrayPtr<const ArrayPtr<const byte>> pieces);



};

class BufferedInputStream: public InputStream {





public:
  virtual ~BufferedInputStream() noexcept(false);

  ArrayPtr<const byte> getReadBuffer();




  virtual ArrayPtr<const byte> tryGetReadBuffer() = 0;

};

class BufferedOutputStream: public OutputStream {





public:
  virtual ~BufferedOutputStream() noexcept(false);

  virtual ArrayPtr<byte> getWriteBuffer() = 0;



};




class BufferedInputStreamWrapper: public BufferedInputStream {
# 129 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 3
public:
  explicit BufferedInputStreamWrapper(InputStream& inner, ArrayPtr<byte> buffer = nullptr);







  BufferedInputStreamWrapper(const BufferedInputStreamWrapper&) = delete; BufferedInputStreamWrapper& operator=(const BufferedInputStreamWrapper&) = delete;
  ~BufferedInputStreamWrapper() noexcept(false);


  ArrayPtr<const byte> tryGetReadBuffer() override;
  size_t tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;
  void skip(size_t bytes) override;

private:
  InputStream& inner;
  Array<byte> ownedBuffer;
  ArrayPtr<byte> buffer;
  ArrayPtr<byte> bufferAvailable;
};

class BufferedOutputStreamWrapper: public BufferedOutputStream {



public:
  explicit BufferedOutputStreamWrapper(OutputStream& inner, ArrayPtr<byte> buffer = nullptr);





  BufferedOutputStreamWrapper(const BufferedOutputStreamWrapper&) = delete; BufferedOutputStreamWrapper& operator=(const BufferedOutputStreamWrapper&) = delete;
  ~BufferedOutputStreamWrapper() noexcept(false);

  void flush();





  ArrayPtr<byte> getWriteBuffer() override;
  void write(const void* buffer, size_t size) override;

private:
  OutputStream& inner;
  Array<byte> ownedBuffer;
  ArrayPtr<byte> buffer;
  byte* bufferPos;
  UnwindDetector unwindDetector;
};




class ArrayInputStream: public BufferedInputStream {
public:
  explicit ArrayInputStream(ArrayPtr<const byte> array);
  ArrayInputStream(const ArrayInputStream&) = delete; ArrayInputStream& operator=(const ArrayInputStream&) = delete;
  ~ArrayInputStream() noexcept(false);


  ArrayPtr<const byte> tryGetReadBuffer() override;
  size_t tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;
  void skip(size_t bytes) override;

private:
  ArrayPtr<const byte> array;
};

class ArrayOutputStream: public BufferedOutputStream {
public:
  explicit ArrayOutputStream(ArrayPtr<byte> array);
  ArrayOutputStream(const ArrayOutputStream&) = delete; ArrayOutputStream& operator=(const ArrayOutputStream&) = delete;
  ~ArrayOutputStream() noexcept(false);

  ArrayPtr<byte> getArray() {

    return arrayPtr(array.begin(), fillPos);
  }


  ArrayPtr<byte> getWriteBuffer() override;
  void write(const void* buffer, size_t size) override;

private:
  ArrayPtr<byte> array;
  byte* fillPos;
};

class VectorOutputStream: public BufferedOutputStream {
public:
  explicit VectorOutputStream(size_t initialCapacity = 4096);
  VectorOutputStream(const VectorOutputStream&) = delete; VectorOutputStream& operator=(const VectorOutputStream&) = delete;
  ~VectorOutputStream() noexcept(false);

  ArrayPtr<byte> getArray() {

    return arrayPtr(vector.begin(), fillPos);
  }


  ArrayPtr<byte> getWriteBuffer() override;
  void write(const void* buffer, size_t size) override;

private:
  Array<byte> vector;
  byte* fillPos;

  void grow(size_t minSize);
};




class AutoCloseFd {
# 256 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 3
public:
  inline AutoCloseFd(): fd(-1) {}
  inline AutoCloseFd(decltype(nullptr)): fd(-1) {}
  inline explicit AutoCloseFd(int fd): fd(fd) {}
  inline AutoCloseFd(AutoCloseFd&& other) noexcept: fd(other.fd) { other.fd = -1; }
  AutoCloseFd(const AutoCloseFd&) = delete; AutoCloseFd& operator=(const AutoCloseFd&) = delete;
  ~AutoCloseFd() noexcept(false);

  inline AutoCloseFd& operator=(AutoCloseFd&& other) {
    AutoCloseFd old(kj::mv(*this));
    fd = other.fd;
    other.fd = -1;
    return *this;
  }

  inline AutoCloseFd& operator=(decltype(nullptr)) {
    AutoCloseFd old(kj::mv(*this));
    return *this;
  }

  inline operator int() const { return fd; }
  inline int get() const { return fd; }

  operator bool() const = delete;



  inline bool operator==(decltype(nullptr)) { return fd < 0; }
  inline bool operator!=(decltype(nullptr)) { return fd >= 0; }

private:
  int fd;
  UnwindDetector unwindDetector;
};

inline auto operator*(::kj::_::Stringifier, const AutoCloseFd& fd)
    -> decltype(kj::toCharSequence(implicitCast<int>(fd))) {
  return kj::toCharSequence(implicitCast<int>(fd));
}

class FdInputStream: public InputStream {


public:
  explicit FdInputStream(int fd): fd(fd) {}
  explicit FdInputStream(AutoCloseFd fd): fd(fd), autoclose(mv(fd)) {}
  FdInputStream(const FdInputStream&) = delete; FdInputStream& operator=(const FdInputStream&) = delete;
  ~FdInputStream() noexcept(false);

  size_t tryRead(void* buffer, size_t minBytes, size_t maxBytes) override;

  inline int getFd() const { return fd; }

private:
  int fd;
  AutoCloseFd autoclose;
};

class FdOutputStream: public OutputStream {


public:
  explicit FdOutputStream(int fd): fd(fd) {}
  explicit FdOutputStream(AutoCloseFd fd): fd(fd), autoclose(mv(fd)) {}
  FdOutputStream(const FdOutputStream&) = delete; FdOutputStream& operator=(const FdOutputStream&) = delete;
  ~FdOutputStream() noexcept(false);

  void write(const void* buffer, size_t size) override;
  void write(ArrayPtr<const ArrayPtr<const byte>> pieces) override;

  inline int getFd() const { return fd; }

private:
  int fd;
  AutoCloseFd autoclose;
};
# 417 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/io.h" 3
}
# 50 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 2 3

namespace capnp {

class FlatArrayMessageReader: public MessageReader {



public:
  FlatArrayMessageReader(kj::ArrayPtr<const word> array, ReaderOptions options = ReaderOptions());


  kj::ArrayPtr<const word> getSegment(uint id) override;

  const word* getEnd() const { return end; }





private:

  kj::ArrayPtr<const word> segment0;
  kj::Array<kj::ArrayPtr<const word>> moreSegments;
  const word* end;
};

kj::ArrayPtr<const word> initMessageBuilderFromFlatArrayCopy(
    kj::ArrayPtr<const word> array, MessageBuilder& target,
    ReaderOptions options = ReaderOptions());
# 91 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3
kj::Array<word> messageToFlatArray(MessageBuilder& builder);
# 102 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3
kj::Array<word> messageToFlatArray(kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);


size_t computeSerializedSizeInWords(MessageBuilder& builder);


size_t computeSerializedSizeInWords(kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);


size_t expectedSizeInWordsFromPrefix(kj::ArrayPtr<const word> messagePrefix);
# 127 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3
class InputStreamMessageReader: public MessageReader {



public:
  InputStreamMessageReader(kj::InputStream& inputStream,
                           ReaderOptions options = ReaderOptions(),
                           kj::ArrayPtr<word> scratchSpace = nullptr);
  ~InputStreamMessageReader() noexcept(false);


  kj::ArrayPtr<const word> getSegment(uint id) override;

private:
  kj::InputStream& inputStream;
  byte* readPos;


  kj::ArrayPtr<const word> segment0;
  kj::Array<kj::ArrayPtr<const word>> moreSegments;

  kj::Array<word> ownedSpace;


  kj::UnwindDetector unwindDetector;
};

void readMessageCopy(kj::InputStream& input, MessageBuilder& target,
                     ReaderOptions options = ReaderOptions(),
                     kj::ArrayPtr<word> scratchSpace = nullptr);
# 165 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3
void writeMessage(kj::OutputStream& output, MessageBuilder& builder);


void writeMessage(kj::OutputStream& output, kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);





class StreamFdMessageReader: private kj::FdInputStream, public InputStreamMessageReader {


public:
  StreamFdMessageReader(int fd, ReaderOptions options = ReaderOptions(),
                        kj::ArrayPtr<word> scratchSpace = nullptr)
      : FdInputStream(fd), InputStreamMessageReader(*this, options, scratchSpace) {}


  StreamFdMessageReader(kj::AutoCloseFd fd, ReaderOptions options = ReaderOptions(),
                        kj::ArrayPtr<word> scratchSpace = nullptr)
      : FdInputStream(kj::mv(fd)), InputStreamMessageReader(*this, options, scratchSpace) {}


  ~StreamFdMessageReader() noexcept(false);
};

void readMessageCopyFromFd(int fd, MessageBuilder& target,
                           ReaderOptions options = ReaderOptions(),
                           kj::ArrayPtr<word> scratchSpace = nullptr);
# 202 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3
void writeMessageToFd(int fd, MessageBuilder& builder);






void writeMessageToFd(int fd, kj::ArrayPtr<const kj::ArrayPtr<const word>> segments);
# 219 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../serialize.h" 3
inline kj::Array<word> messageToFlatArray(MessageBuilder& builder) {
  return messageToFlatArray(builder.getSegmentsForOutput());
}

inline size_t computeSerializedSizeInWords(MessageBuilder& builder) {
  return computeSerializedSizeInWords(builder.getSegmentsForOutput());
}

inline void writeMessage(kj::OutputStream& output, MessageBuilder& builder) {
  writeMessage(output, builder.getSegmentsForOutput());
}

inline void writeMessageToFd(int fd, MessageBuilder& builder) {
  writeMessageToFd(fd, builder.getSegmentsForOutput());
}

}
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/vector.h" 1
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/vector.h"
#define KJ_VECTOR_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/vector.h" 3




namespace kj {

template <typename T>
class Vector {
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/vector.h" 3
public:
  inline Vector() = default;
  inline explicit Vector(size_t capacity): builder(heapArrayBuilder<T>(capacity)) {}

  inline operator ArrayPtr<T>() { return builder; }
  inline operator ArrayPtr<const T>() const { return builder; }
  inline ArrayPtr<T> asPtr() { return builder.asPtr(); }
  inline ArrayPtr<const T> asPtr() const { return builder.asPtr(); }

  inline size_t size() const { return builder.size(); }
  inline bool empty() const { return size() == 0; }
  inline size_t capacity() const { return builder.capacity(); }
  inline T& operator[](size_t index) const { return builder[index]; }

  inline const T* begin() const { return builder.begin(); }
  inline const T* end() const { return builder.end(); }
  inline const T& front() const { return builder.front(); }
  inline const T& back() const { return builder.back(); }
  inline T* begin() { return builder.begin(); }
  inline T* end() { return builder.end(); }
  inline T& front() { return builder.front(); }
  inline T& back() { return builder.back(); }

  inline Array<T> releaseAsArray() {

    if (!builder.isFull()) {
      setCapacity(size());
    }
    return builder.finish();
  }

  template <typename... Params>
  inline T& add(Params&&... params) {
    if (builder.isFull()) grow();
    return builder.add(kj::fwd<Params>(params)...);
  }

  template <typename Iterator>
  inline void addAll(Iterator begin, Iterator end) {
    size_t needed = builder.size() + (end - begin);
    if (needed > builder.capacity()) grow(needed);
    builder.addAll(begin, end);
  }

  template <typename Container>
  inline void addAll(Container&& container) {
    addAll(container.begin(), container.end());
  }

  inline void removeLast() {
    builder.removeLast();
  }

  inline void resize(size_t size) {
    if (size > builder.capacity()) grow(size);
    builder.resize(size);
  }

  inline void operator=(decltype(nullptr)) {
    builder = nullptr;
  }

  inline void clear() {
    while (builder.size() > 0) {
      builder.removeLast();
    }
  }

  inline void truncate(size_t size) {
    builder.truncate(size);
  }

  inline void reserve(size_t size) {
    if (size > builder.capacity()) {
      setCapacity(size);
    }
  }

private:
  ArrayBuilder<T> builder;

  void grow(size_t minCapacity = 0) {
    setCapacity(kj::max(minCapacity, capacity() == 0 ? 4 : capacity() * 2));
  }
  void setCapacity(size_t newSize) {
    if (builder.size() > newSize) {
      builder.truncate(newSize);
    }
    ArrayBuilder<T> newBuilder = heapArrayBuilder<T>(newSize);
    newBuilder.addAll(kj::mv(builder));
    builder = kj::mv(newBuilder);
  }
};

template <typename T>
inline auto operator*(::kj::_::Stringifier, const Vector<T>& v) -> decltype(toCharSequence(v.asPtr())) {
  return toCharSequence(v.asPtr());
}

}
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 1
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h"
#define CAPNP_SCHEMA_LOADER_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 3
#define CAPNP_SCHEMA_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 3








namespace capnp {

class Schema;
class StructSchema;
class EnumSchema;
class InterfaceSchema;
class ConstSchema;
class ListSchema;
class Type;

template <typename T, Kind k = kind<T>()> struct SchemaType_ { typedef Schema Type; };
template <typename T> struct SchemaType_<T, Kind::PRIMITIVE> { typedef schema::Type::Which Type; };
template <typename T> struct SchemaType_<T, Kind::BLOB> { typedef schema::Type::Which Type; };
template <typename T> struct SchemaType_<T, Kind::ENUM> { typedef EnumSchema Type; };
template <typename T> struct SchemaType_<T, Kind::STRUCT> { typedef StructSchema Type; };
template <typename T> struct SchemaType_<T, Kind::INTERFACE> { typedef InterfaceSchema Type; };
template <typename T> struct SchemaType_<T, Kind::LIST> { typedef ListSchema Type; };

template <typename T>
using SchemaType = typename SchemaType_<T>::Type;


namespace _ {
extern const RawSchema NULL_SCHEMA;
extern const RawSchema NULL_STRUCT_SCHEMA;
extern const RawSchema NULL_ENUM_SCHEMA;
extern const RawSchema NULL_INTERFACE_SCHEMA;
extern const RawSchema NULL_CONST_SCHEMA;


}

class Schema {


public:
  inline Schema(): raw(&_::NULL_SCHEMA.defaultBrand) {}

  template <typename T>
  static inline SchemaType<T> from() { return SchemaType<T>::template fromImpl<T>(); }


  schema::Node::Reader getProto() const;



  kj::ArrayPtr<const word> asUncheckedMessage() const;



  Schema getDependency(uint64_t id) const __attribute__((deprecated("Does not handle generics correctly.")));
# 109 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 3
  bool isBranded() const;


  Schema getGeneric() const;


  class BrandArgumentList;
  BrandArgumentList getBrandArgumentsAtScope(uint64_t scopeId) const;


  StructSchema asStruct() const;
  EnumSchema asEnum() const;
  InterfaceSchema asInterface() const;
  ConstSchema asConst() const;



  inline bool operator==(const Schema& other) const { return raw == other.raw; }
  inline bool operator!=(const Schema& other) const { return raw != other.raw; }




  template <typename T>
  void requireUsableAs() const;






  kj::StringPtr getShortDisplayName() const;


private:
  const _::RawBrandedSchema* raw;

  inline explicit Schema(const _::RawBrandedSchema* raw): raw(raw) {

                                                                                 ;
  }

  template <typename T> static inline Schema fromImpl() {
    return Schema(&_::rawSchema<T>());
  }

  void requireUsableAs(const _::RawSchema* expected) const;

  uint32_t getSchemaOffset(const schema::Value::Reader& value) const;

  Type getBrandBinding(uint64_t scopeId, uint index) const;





  Schema getDependency(uint64_t id, uint location) const;



  Type interpretType(schema::Type::Reader proto, uint location) const;



  friend class StructSchema;
  friend class EnumSchema;
  friend class InterfaceSchema;
  friend class ConstSchema;
  friend class ListSchema;
  friend class SchemaLoader;
  friend class Type;
  friend kj::StringTree _::structString(
      _::StructReader reader, const _::RawBrandedSchema& schema);
  friend kj::String _::enumString(uint16_t value, const _::RawBrandedSchema& schema);
};

kj::StringPtr operator*(::kj::_::Stringifier, const Schema& schema);

class Schema::BrandArgumentList {
# 197 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 3
public:
  inline BrandArgumentList(): scopeId(0), size_(0), bindings(nullptr) {}

  inline uint size() const { return size_; }
  Type operator[](uint index) const;

  typedef _::IndexingIterator<const BrandArgumentList, Type> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  uint64_t scopeId;
  uint size_;
  bool isUnbound;
  const _::RawBrandedSchema::Binding* bindings;

  inline BrandArgumentList(uint64_t scopeId, bool isUnbound)
      : scopeId(scopeId), size_(0), isUnbound(isUnbound), bindings(nullptr) {}
  inline BrandArgumentList(uint64_t scopeId, uint size,
                           const _::RawBrandedSchema::Binding* bindings)
      : scopeId(scopeId), size_(size), isUnbound(false), bindings(bindings) {}

  friend class Schema;
};



class StructSchema: public Schema {
public:
  inline StructSchema(): Schema(&_::NULL_STRUCT_SCHEMA.defaultBrand) {}

  class Field;
  class FieldList;
  class FieldSubset;

  FieldList getFields() const;




  FieldSubset getUnionFields() const;




  FieldSubset getNonUnionFields() const;


  kj::Maybe<Field> findFieldByName(kj::StringPtr name) const;






  Field getFieldByName(kj::StringPtr name) const;


  kj::Maybe<Field> getFieldByDiscriminant(uint16_t discriminant) const;




private:
  StructSchema(Schema base): Schema(base) {}
  template <typename T> static inline StructSchema fromImpl() {
    return StructSchema(Schema(&_::rawBrandedSchema<T>()));
  }
  friend class Schema;
  friend class Type;
};

class StructSchema::Field {
public:
  Field() = default;

  inline schema::Field::Reader getProto() const { return proto; }
  inline StructSchema getContainingStruct() const { return parent; }

  inline uint getIndex() const { return index; }


  Type getType() const;



  uint32_t getDefaultValueSchemaOffset() const;
# 303 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 3
  inline bool operator==(const Field& other) const;
  inline bool operator!=(const Field& other) const { return !(*this == other); }

private:
  StructSchema parent;
  uint index;
  schema::Field::Reader proto;

  inline Field(StructSchema parent, uint index, schema::Field::Reader proto)
      : parent(parent), index(index), proto(proto) {}

  friend class StructSchema;
};

kj::StringPtr operator*(::kj::_::Stringifier, const StructSchema::Field& field);

class StructSchema::FieldList {
public:
  FieldList() = default;

  inline uint size() const { return list.size(); }
  inline Field operator[](uint index) const { return Field(parent, index, list[index]); }

  typedef _::IndexingIterator<const FieldList, Field> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  StructSchema parent;
  List<schema::Field>::Reader list;

  inline FieldList(StructSchema parent, List<schema::Field>::Reader list)
      : parent(parent), list(list) {}

  friend class StructSchema;
};

class StructSchema::FieldSubset {
public:
  FieldSubset() = default;

  inline uint size() const { return size_; }
  inline Field operator[](uint index) const {
    return Field(parent, indices[index], list[indices[index]]);
  }

  typedef _::IndexingIterator<const FieldSubset, Field> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  StructSchema parent;
  List<schema::Field>::Reader list;
  const uint16_t* indices;
  uint size_;

  inline FieldSubset(StructSchema parent, List<schema::Field>::Reader list,
                     const uint16_t* indices, uint size)
      : parent(parent), list(list), indices(indices), size_(size) {}

  friend class StructSchema;
};



class EnumSchema: public Schema {
public:
  inline EnumSchema(): Schema(&_::NULL_ENUM_SCHEMA.defaultBrand) {}

  class Enumerant;
  class EnumerantList;

  EnumerantList getEnumerants() const;

  kj::Maybe<Enumerant> findEnumerantByName(kj::StringPtr name) const;

  Enumerant getEnumerantByName(kj::StringPtr name) const;


private:
  EnumSchema(Schema base): Schema(base) {}
  template <typename T> static inline EnumSchema fromImpl() {
    return EnumSchema(Schema(&_::rawBrandedSchema<T>()));
  }
  friend class Schema;
  friend class Type;
};

class EnumSchema::Enumerant {
public:
  Enumerant() = default;

  inline schema::Enumerant::Reader getProto() const { return proto; }
  inline EnumSchema getContainingEnum() const { return parent; }

  inline uint16_t getOrdinal() const { return ordinal; }
  inline uint getIndex() const { return ordinal; }

  inline bool operator==(const Enumerant& other) const;
  inline bool operator!=(const Enumerant& other) const { return !(*this == other); }

private:
  EnumSchema parent;
  uint16_t ordinal;
  schema::Enumerant::Reader proto;

  inline Enumerant(EnumSchema parent, uint16_t ordinal, schema::Enumerant::Reader proto)
      : parent(parent), ordinal(ordinal), proto(proto) {}

  friend class EnumSchema;
};

class EnumSchema::EnumerantList {
public:
  EnumerantList() = default;

  inline uint size() const { return list.size(); }
  inline Enumerant operator[](uint index) const { return Enumerant(parent, index, list[index]); }

  typedef _::IndexingIterator<const EnumerantList, Enumerant> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  EnumSchema parent;
  List<schema::Enumerant>::Reader list;

  inline EnumerantList(EnumSchema parent, List<schema::Enumerant>::Reader list)
      : parent(parent), list(list) {}

  friend class EnumSchema;
};



class InterfaceSchema: public Schema {
public:
  inline InterfaceSchema(): Schema(&_::NULL_INTERFACE_SCHEMA.defaultBrand) {}

  class Method;
  class MethodList;

  MethodList getMethods() const;

  kj::Maybe<Method> findMethodByName(kj::StringPtr name) const;

  Method getMethodByName(kj::StringPtr name) const;


  class SuperclassList;

  SuperclassList getSuperclasses() const;


  bool extends(InterfaceSchema other) const;


  kj::Maybe<InterfaceSchema> findSuperclass(uint64_t typeId) const;



private:
  InterfaceSchema(Schema base): Schema(base) {}
  template <typename T> static inline InterfaceSchema fromImpl() {
    return InterfaceSchema(Schema(&_::rawBrandedSchema<T>()));
  }
  friend class Schema;
  friend class Type;

  kj::Maybe<Method> findMethodByName(kj::StringPtr name, uint& counter) const;
  bool extends(InterfaceSchema other, uint& counter) const;
  kj::Maybe<InterfaceSchema> findSuperclass(uint64_t typeId, uint& counter) const;


};

class InterfaceSchema::Method {
public:
  Method() = default;

  inline schema::Method::Reader getProto() const { return proto; }
  inline InterfaceSchema getContainingInterface() const { return parent; }

  inline uint16_t getOrdinal() const { return ordinal; }
  inline uint getIndex() const { return ordinal; }

  StructSchema getParamType() const;
  StructSchema getResultType() const;


  inline bool operator==(const Method& other) const;
  inline bool operator!=(const Method& other) const { return !(*this == other); }

private:
  InterfaceSchema parent;
  uint16_t ordinal;
  schema::Method::Reader proto;

  inline Method(InterfaceSchema parent, uint16_t ordinal,
                schema::Method::Reader proto)
      : parent(parent), ordinal(ordinal), proto(proto) {}

  friend class InterfaceSchema;
};

class InterfaceSchema::MethodList {
public:
  MethodList() = default;

  inline uint size() const { return list.size(); }
  inline Method operator[](uint index) const { return Method(parent, index, list[index]); }

  typedef _::IndexingIterator<const MethodList, Method> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  InterfaceSchema parent;
  List<schema::Method>::Reader list;

  inline MethodList(InterfaceSchema parent, List<schema::Method>::Reader list)
      : parent(parent), list(list) {}

  friend class InterfaceSchema;
};

class InterfaceSchema::SuperclassList {
public:
  SuperclassList() = default;

  inline uint size() const { return list.size(); }
  InterfaceSchema operator[](uint index) const;

  typedef _::IndexingIterator<const SuperclassList, InterfaceSchema> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  InterfaceSchema parent;
  List<schema::Superclass>::Reader list;

  inline SuperclassList(InterfaceSchema parent, List<schema::Superclass>::Reader list)
      : parent(parent), list(list) {}

  friend class InterfaceSchema;
};



class ConstSchema: public Schema {




public:
  inline ConstSchema(): Schema(&_::NULL_CONST_SCHEMA.defaultBrand) {}

  template <typename T>
  ReaderFor<T> as() const;




  uint32_t getValueSchemaOffset() const;




  Type getType() const;

private:
  ConstSchema(Schema base): Schema(base) {}
  friend class Schema;
};



class Type {
public:
  struct BrandParameter {
    uint64_t scopeId;
    uint index;
  };
  struct ImplicitParameter {
    uint index;
  };

  inline Type();
  inline Type(schema::Type::Which primitive);
  inline Type(StructSchema schema);
  inline Type(EnumSchema schema);
  inline Type(InterfaceSchema schema);
  inline Type(ListSchema schema);
  inline Type(schema::Type::AnyPointer::Unconstrained::Which anyPointerKind);
  inline Type(BrandParameter param);
  inline Type(ImplicitParameter param);

  template <typename T>
  inline static Type from();

  inline schema::Type::Which which() const;

  StructSchema asStruct() const;
  EnumSchema asEnum() const;
  InterfaceSchema asInterface() const;
  ListSchema asList() const;


  kj::Maybe<BrandParameter> getBrandParameter() const;



  kj::Maybe<ImplicitParameter> getImplicitParameter() const;



  inline schema::Type::AnyPointer::Unconstrained::Which whichAnyPointerKind() const;


  inline bool isVoid() const;
  inline bool isBool() const;
  inline bool isInt8() const;
  inline bool isInt16() const;
  inline bool isInt32() const;
  inline bool isInt64() const;
  inline bool isUInt8() const;
  inline bool isUInt16() const;
  inline bool isUInt32() const;
  inline bool isUInt64() const;
  inline bool isFloat32() const;
  inline bool isFloat64() const;
  inline bool isText() const;
  inline bool isData() const;
  inline bool isList() const;
  inline bool isEnum() const;
  inline bool isStruct() const;
  inline bool isInterface() const;
  inline bool isAnyPointer() const;

  bool operator==(const Type& other) const;
  inline bool operator!=(const Type& other) const { return !(*this == other); }

  size_t hashCode() const;

  inline Type wrapInList(uint depth = 1) const;


  inline Type(schema::Type::Which derived, const _::RawBrandedSchema* schema);


private:
  schema::Type::Which baseType;
  uint8_t listDepth;

  bool isImplicitParam;



  union {
    uint16_t paramIndex;




    schema::Type::AnyPointer::Unconstrained::Which anyPointerKind;

  };

  union {
    const _::RawBrandedSchema* schema;
    uint64_t scopeId;
  };

  Type(schema::Type::Which baseType, uint8_t listDepth, const _::RawBrandedSchema* schema)
      : baseType(baseType), listDepth(listDepth), schema(schema) {
                                                      ;
  }

  void requireUsableAs(Type expected) const;

  friend class ListSchema;
};



class ListSchema {



public:
  ListSchema() = default;

  static ListSchema of(schema::Type::Which primitiveType);
  static ListSchema of(StructSchema elementType);
  static ListSchema of(EnumSchema elementType);
  static ListSchema of(InterfaceSchema elementType);
  static ListSchema of(ListSchema elementType);
  static ListSchema of(Type elementType);


  static ListSchema of(schema::Type::Reader elementType, Schema context)
      __attribute__((deprecated("Does not handle generics correctly.")));
# 713 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/schema.h" 3
  Type getElementType() const;

  inline schema::Type::Which whichElementType() const;




  StructSchema getStructElementType() const;
  EnumSchema getEnumElementType() const;
  InterfaceSchema getInterfaceElementType() const;
  ListSchema getListElementType() const;



  inline bool operator==(const ListSchema& other) const { return elementType == other.elementType; }
  inline bool operator!=(const ListSchema& other) const { return elementType != other.elementType; }

  template <typename T>
  void requireUsableAs() const;

private:
  Type elementType;

  inline explicit ListSchema(Type elementType): elementType(elementType) {}

  template <typename T>
  struct FromImpl;
  template <typename T> static inline ListSchema fromImpl() {
    return FromImpl<T>::get();
  }

  void requireUsableAs(ListSchema expected) const;

  friend class Schema;
};




template <> inline schema::Type::Which Schema::from<Void>() { return schema::Type::VOID; }
template <> inline schema::Type::Which Schema::from<bool>() { return schema::Type::BOOL; }
template <> inline schema::Type::Which Schema::from<int8_t>() { return schema::Type::INT8; }
template <> inline schema::Type::Which Schema::from<int16_t>() { return schema::Type::INT16; }
template <> inline schema::Type::Which Schema::from<int32_t>() { return schema::Type::INT32; }
template <> inline schema::Type::Which Schema::from<int64_t>() { return schema::Type::INT64; }
template <> inline schema::Type::Which Schema::from<uint8_t>() { return schema::Type::UINT8; }
template <> inline schema::Type::Which Schema::from<uint16_t>() { return schema::Type::UINT16; }
template <> inline schema::Type::Which Schema::from<uint32_t>() { return schema::Type::UINT32; }
template <> inline schema::Type::Which Schema::from<uint64_t>() { return schema::Type::UINT64; }
template <> inline schema::Type::Which Schema::from<float>() { return schema::Type::FLOAT32; }
template <> inline schema::Type::Which Schema::from<double>() { return schema::Type::FLOAT64; }
template <> inline schema::Type::Which Schema::from<Text>() { return schema::Type::TEXT; }
template <> inline schema::Type::Which Schema::from<Data>() { return schema::Type::DATA; }

inline Schema Schema::getDependency(uint64_t id) const {
  return getDependency(id, 0);
}

inline bool Schema::isBranded() const {
  return raw != &raw->generic->defaultBrand;
}

inline Schema Schema::getGeneric() const {
  return Schema(&raw->generic->defaultBrand);
}

template <typename T>
inline void Schema::requireUsableAs() const {
  requireUsableAs(&_::rawSchema<T>());
}

inline bool StructSchema::Field::operator==(const Field& other) const {
  return parent == other.parent && index == other.index;
}
inline bool EnumSchema::Enumerant::operator==(const Enumerant& other) const {
  return parent == other.parent && ordinal == other.ordinal;
}
inline bool InterfaceSchema::Method::operator==(const Method& other) const {
  return parent == other.parent && ordinal == other.ordinal;
}

inline ListSchema ListSchema::of(StructSchema elementType) {
  return ListSchema(Type(elementType));
}
inline ListSchema ListSchema::of(EnumSchema elementType) {
  return ListSchema(Type(elementType));
}
inline ListSchema ListSchema::of(InterfaceSchema elementType) {
  return ListSchema(Type(elementType));
}
inline ListSchema ListSchema::of(ListSchema elementType) {
  return ListSchema(Type(elementType));
}
inline ListSchema ListSchema::of(Type elementType) {
  return ListSchema(elementType);
}

inline Type ListSchema::getElementType() const {
  return elementType;
}

inline schema::Type::Which ListSchema::whichElementType() const {
  return elementType.which();
}

inline StructSchema ListSchema::getStructElementType() const {
  return elementType.asStruct();
}

inline EnumSchema ListSchema::getEnumElementType() const {
  return elementType.asEnum();
}

inline InterfaceSchema ListSchema::getInterfaceElementType() const {
  return elementType.asInterface();
}

inline ListSchema ListSchema::getListElementType() const {
  return elementType.asList();
}

template <typename T>
inline void ListSchema::requireUsableAs() const {
  static_assert(kind<T>() == Kind::LIST,
                "ListSchema::requireUsableAs<T>() requires T is a list type.");
  requireUsableAs(Schema::from<T>());
}

inline void ListSchema::requireUsableAs(ListSchema expected) const {
  elementType.requireUsableAs(expected.elementType);
}

template <typename T>
struct ListSchema::FromImpl<List<T>> {
  static inline ListSchema get() { return of(Schema::from<T>()); }
};

inline Type::Type(): baseType(schema::Type::VOID), listDepth(0), schema(nullptr) {}
inline Type::Type(schema::Type::Which primitive)
    : baseType(primitive), listDepth(0), isImplicitParam(false) {



                                              ;
  if (primitive == schema::Type::ANY_POINTER) {
    scopeId = 0;
    anyPointerKind = schema::Type::AnyPointer::Unconstrained::ANY_KIND;
  } else {
    schema = nullptr;
  }
}
inline Type::Type(schema::Type::Which derived, const _::RawBrandedSchema* schema)
    : baseType(derived), listDepth(0), isImplicitParam(false), schema(schema) {


                                                 ;
}

inline Type::Type(StructSchema schema)
    : baseType(schema::Type::STRUCT), listDepth(0), schema(schema.raw) {}
inline Type::Type(EnumSchema schema)
    : baseType(schema::Type::ENUM), listDepth(0), schema(schema.raw) {}
inline Type::Type(InterfaceSchema schema)
    : baseType(schema::Type::INTERFACE), listDepth(0), schema(schema.raw) {}
inline Type::Type(ListSchema schema)
    : Type(schema.getElementType()) { ++listDepth; }
inline Type::Type(schema::Type::AnyPointer::Unconstrained::Which anyPointerKind)
    : baseType(schema::Type::ANY_POINTER), listDepth(0), isImplicitParam(false),
      anyPointerKind(anyPointerKind), scopeId(0) {}
inline Type::Type(BrandParameter param)
    : baseType(schema::Type::ANY_POINTER), listDepth(0), isImplicitParam(false),
      paramIndex(param.index), scopeId(param.scopeId) {}
inline Type::Type(ImplicitParameter param)
    : baseType(schema::Type::ANY_POINTER), listDepth(0), isImplicitParam(true),
      paramIndex(param.index), scopeId(0) {}

inline schema::Type::Which Type::which() const {
  return listDepth > 0 ? schema::Type::LIST : baseType;
}

inline schema::Type::AnyPointer::Unconstrained::Which Type::whichAnyPointerKind() const {
                                                    ;
  return !isImplicitParam && scopeId == 0 ? anyPointerKind
      : schema::Type::AnyPointer::Unconstrained::ANY_KIND;
}

template <typename T>
inline Type Type::from() { return Type(Schema::from<T>()); }

inline bool Type::isVoid () const { return baseType == schema::Type::VOID && listDepth == 0; }
inline bool Type::isBool () const { return baseType == schema::Type::BOOL && listDepth == 0; }
inline bool Type::isInt8 () const { return baseType == schema::Type::INT8 && listDepth == 0; }
inline bool Type::isInt16 () const { return baseType == schema::Type::INT16 && listDepth == 0; }
inline bool Type::isInt32 () const { return baseType == schema::Type::INT32 && listDepth == 0; }
inline bool Type::isInt64 () const { return baseType == schema::Type::INT64 && listDepth == 0; }
inline bool Type::isUInt8 () const { return baseType == schema::Type::UINT8 && listDepth == 0; }
inline bool Type::isUInt16 () const { return baseType == schema::Type::UINT16 && listDepth == 0; }
inline bool Type::isUInt32 () const { return baseType == schema::Type::UINT32 && listDepth == 0; }
inline bool Type::isUInt64 () const { return baseType == schema::Type::UINT64 && listDepth == 0; }
inline bool Type::isFloat32() const { return baseType == schema::Type::FLOAT32 && listDepth == 0; }
inline bool Type::isFloat64() const { return baseType == schema::Type::FLOAT64 && listDepth == 0; }
inline bool Type::isText () const { return baseType == schema::Type::TEXT && listDepth == 0; }
inline bool Type::isData () const { return baseType == schema::Type::DATA && listDepth == 0; }
inline bool Type::isList () const { return listDepth > 0; }
inline bool Type::isEnum () const { return baseType == schema::Type::ENUM && listDepth == 0; }
inline bool Type::isStruct () const { return baseType == schema::Type::STRUCT && listDepth == 0; }
inline bool Type::isInterface() const {
  return baseType == schema::Type::INTERFACE && listDepth == 0;
}
inline bool Type::isAnyPointer() const {
  return baseType == schema::Type::ANY_POINTER && listDepth == 0;
}

inline Type Type::wrapInList(uint depth) const {
  Type result = *this;
  result.listDepth += depth;
  return result;
}

}
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 2 3



namespace capnp {

class SchemaLoader {
# 46 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 3
public:
  class LazyLoadCallback {
  public:
    virtual void load(const SchemaLoader& loader, uint64_t id) const = 0;
# 61 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 3
  };

  SchemaLoader();

  SchemaLoader(const LazyLoadCallback& callback);



  ~SchemaLoader() noexcept(false);
  SchemaLoader(const SchemaLoader&) = delete; SchemaLoader& operator=(const SchemaLoader&) = delete;

  Schema get(uint64_t id, schema::Brand::Reader brand = schema::Brand::Reader(),
             Schema scope = Schema()) const;
# 85 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 3
  kj::Maybe<Schema> tryGet(uint64_t id, schema::Brand::Reader bindings = schema::Brand::Reader(),
                           Schema scope = Schema()) const;


  Schema getUnbound(uint64_t id) const;






  Type getType(schema::Type::Reader type, Schema scope = Schema()) const;



  Schema load(const schema::Node::Reader& reader);
# 135 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../schema-loader.h" 3
  Schema loadOnce(const schema::Node::Reader& reader) const;






  template <typename T>
  void loadCompiledTypeAndDependencies();






  kj::Array<Schema> getAllLoaded() const;




private:
  class Validator;
  class CompatibilityChecker;
  class Impl;
  class InitializerImpl;
  class BrandedInitializerImpl;
  kj::MutexGuarded<kj::Own<Impl>> impl;

  void loadNative(const _::RawSchema* nativeSchema);
};

template <typename T>
inline void SchemaLoader::loadCompiledTypeAndDependencies() {
  loadNative(&_::rawSchema<T>());
}

}
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h" 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h"
#define CAPNP_DYNAMIC_H_ 
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h" 3




# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/message.h" 1 3
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
#define CAPNP_CAPABILITY_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
#define KJ_ASYNC_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-prelude.h" 1 3
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-prelude.h" 3
#define KJ_ASYNC_PRELUDE_H_ 
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-prelude.h" 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/tuple.h" 1 3
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/tuple.h" 3
#define KJ_TUPLE_H_ 
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/tuple.h" 3




namespace kj {
namespace _ {

template <size_t index, typename... T>
struct TypeByIndex_;
template <typename First, typename... Rest>
struct TypeByIndex_<0, First, Rest...> {
  typedef First Type;
};
template <size_t index, typename First, typename... Rest>
struct TypeByIndex_<index, First, Rest...>
    : public TypeByIndex_<index - 1, Rest...> {};
template <size_t index>
struct TypeByIndex_<index> {
  static_assert(index != index, "Index out-of-range.");
};
template <size_t index, typename... T>
using TypeByIndex = typename TypeByIndex_<index, T...>::Type;


template <size_t... s>
struct Indexes {};



template <size_t end, size_t... prefix>
struct MakeIndexes_: public MakeIndexes_<end - 1, end - 1, prefix...> {};
template <size_t... prefix>
struct MakeIndexes_<0, prefix...> {
  typedef Indexes<prefix...> Type;
};
template <size_t end>
using MakeIndexes = typename MakeIndexes_<end>::Type;


template <typename... T>
class Tuple;
template <size_t index, typename... U>
inline TypeByIndex<index, U...>& getImpl(Tuple<U...>& tuple);
template <size_t index, typename... U>
inline TypeByIndex<index, U...>&& getImpl(Tuple<U...>&& tuple);
template <size_t index, typename... U>
inline const TypeByIndex<index, U...>& getImpl(const Tuple<U...>& tuple);

template <uint index, typename T>
struct TupleElement {



  T value;
  TupleElement() = default;
  constexpr inline TupleElement(const T& value): value(value) {}
  constexpr inline TupleElement(T&& value): value(kj::mv(value)) {}
};

template <uint index, typename T>
struct TupleElement<index, T&> {





  static_assert(sizeof(T*) == 0, "Sorry, tuples cannot contain references.");
};

template <uint index, typename... T>
struct TupleElement<index, Tuple<T...>> {
  static_assert(sizeof(Tuple<T...>*) == 0,
                "Tuples cannot contain other tuples -- they should be flattened.");
};

template <typename Indexes, typename... Types>
struct TupleImpl;

template <size_t... indexes, typename... Types>
struct TupleImpl<Indexes<indexes...>, Types...>
    : public TupleElement<indexes, Types>... {



  static_assert(sizeof...(indexes) == sizeof...(Types), "Incorrect use of TupleImpl.");

  template <typename... Params>
  inline TupleImpl(Params&&... params)
      : TupleElement<indexes, Types>(kj::fwd<Params>(params))... {


    static_assert(sizeof...(params) == sizeof...(indexes),
                  "Wrong number of parameters to Tuple constructor.");
  }

  template <typename... U>
  constexpr inline TupleImpl(Tuple<U...>&& other)
      : TupleElement<indexes, Types>(kj::mv(getImpl<indexes>(other)))... {}
  template <typename... U>
  constexpr inline TupleImpl(Tuple<U...>& other)
      : TupleElement<indexes, Types>(getImpl<indexes>(other))... {}
  template <typename... U>
  constexpr inline TupleImpl(const Tuple<U...>& other)
      : TupleElement<indexes, Types>(getImpl<indexes>(other))... {}
};

struct MakeTupleFunc;

template <typename... T>
class Tuple {


public:
  template <typename... U>
  constexpr inline Tuple(Tuple<U...>&& other): impl(kj::mv(other)) {}
  template <typename... U>
  constexpr inline Tuple(Tuple<U...>& other): impl(other) {}
  template <typename... U>
  constexpr inline Tuple(const Tuple<U...>& other): impl(other) {}

private:
  template <typename... Params>
  constexpr Tuple(Params&&... params): impl(kj::fwd<Params>(params)...) {}

  TupleImpl<MakeIndexes<sizeof...(T)>, T...> impl;

  template <size_t index, typename... U>
  friend inline TypeByIndex<index, U...>& getImpl(Tuple<U...>& tuple);
  template <size_t index, typename... U>
  friend inline TypeByIndex<index, U...>&& getImpl(Tuple<U...>&& tuple);
  template <size_t index, typename... U>
  friend inline const TypeByIndex<index, U...>& getImpl(const Tuple<U...>& tuple);
  friend struct MakeTupleFunc;
};

template <>
class Tuple<> {


};

template <typename T>
class Tuple<T>;


template <size_t index, typename... T>
inline TypeByIndex<index, T...>& getImpl(Tuple<T...>& tuple) {

  static_assert(index < sizeof...(T), "Tuple element index out-of-bounds.");
  return implicitCast<TupleElement<index, TypeByIndex<index, T...>>&>(tuple.impl).value;
}
template <size_t index, typename... T>
inline TypeByIndex<index, T...>&& getImpl(Tuple<T...>&& tuple) {

  static_assert(index < sizeof...(T), "Tuple element index out-of-bounds.");
  return kj::mv(implicitCast<TupleElement<index, TypeByIndex<index, T...>>&>(tuple.impl).value);
}
template <size_t index, typename... T>
inline const TypeByIndex<index, T...>& getImpl(const Tuple<T...>& tuple) {

  static_assert(index < sizeof...(T), "Tuple element index out-of-bounds.");
  return implicitCast<const TupleElement<index, TypeByIndex<index, T...>>&>(tuple.impl).value;
}
template <size_t index, typename T>
inline T&& getImpl(T&& value) {



  static_assert(index == 0, "Tuple element index out-of-bounds.");
  return kj::fwd<T>(value);
}


template <typename Func, typename SoFar, typename... T>
struct ExpandAndApplyResult_;




template <typename Func, typename First, typename... Rest, typename... T>
struct ExpandAndApplyResult_<Func, Tuple<T...>, First, Rest...>
    : public ExpandAndApplyResult_<Func, Tuple<T..., First>, Rest...> {};
template <typename Func, typename... FirstTypes, typename... Rest, typename... T>
struct ExpandAndApplyResult_<Func, Tuple<T...>, Tuple<FirstTypes...>, Rest...>
    : public ExpandAndApplyResult_<Func, Tuple<T...>, FirstTypes&&..., Rest...> {};
template <typename Func, typename... FirstTypes, typename... Rest, typename... T>
struct ExpandAndApplyResult_<Func, Tuple<T...>, Tuple<FirstTypes...>&, Rest...>
    : public ExpandAndApplyResult_<Func, Tuple<T...>, FirstTypes&..., Rest...> {};
template <typename Func, typename... FirstTypes, typename... Rest, typename... T>
struct ExpandAndApplyResult_<Func, Tuple<T...>, const Tuple<FirstTypes...>&, Rest...>
    : public ExpandAndApplyResult_<Func, Tuple<T...>, const FirstTypes&..., Rest...> {};
template <typename Func, typename... T>
struct ExpandAndApplyResult_<Func, Tuple<T...>> {
  typedef decltype(instance<Func>()(instance<T&&>()...)) Type;
};
template <typename Func, typename... T>
using ExpandAndApplyResult = typename ExpandAndApplyResult_<Func, Tuple<>, T...>::Type;


template <typename Func>
inline auto expandAndApply(Func&& func) -> ExpandAndApplyResult<Func> {
  return func();
}

template <typename Func, typename First, typename... Rest>
struct ExpandAndApplyFunc {
  Func&& func;
  First&& first;
  ExpandAndApplyFunc(Func&& func, First&& first)
      : func(kj::fwd<Func>(func)), first(kj::fwd<First>(first)) {}
  template <typename... T>
  auto operator()(T&&... params)
      -> decltype(this->func(kj::fwd<First>(first), kj::fwd<T>(params)...)) {
    return this->func(kj::fwd<First>(first), kj::fwd<T>(params)...);
  }
};

template <typename Func, typename First, typename... Rest>
inline auto expandAndApply(Func&& func, First&& first, Rest&&... rest)
    -> ExpandAndApplyResult<Func, First, Rest...> {

  return expandAndApply(
      ExpandAndApplyFunc<Func, First, Rest...>(kj::fwd<Func>(func), kj::fwd<First>(first)),
      kj::fwd<Rest>(rest)...);
}

template <typename Func, typename... FirstTypes, typename... Rest>
inline auto expandAndApply(Func&& func, Tuple<FirstTypes...>&& first, Rest&&... rest)
    -> ExpandAndApplyResult<Func, FirstTypes&&..., Rest...> {
  return expandAndApplyWithIndexes(MakeIndexes<sizeof...(FirstTypes)>(),
      kj::fwd<Func>(func), kj::mv(first), kj::fwd<Rest>(rest)...);
}

template <typename Func, typename... FirstTypes, typename... Rest>
inline auto expandAndApply(Func&& func, Tuple<FirstTypes...>& first, Rest&&... rest)
    -> ExpandAndApplyResult<Func, FirstTypes..., Rest...> {
  return expandAndApplyWithIndexes(MakeIndexes<sizeof...(FirstTypes)>(),
      kj::fwd<Func>(func), first, kj::fwd<Rest>(rest)...);
}

template <typename Func, typename... FirstTypes, typename... Rest>
inline auto expandAndApply(Func&& func, const Tuple<FirstTypes...>& first, Rest&&... rest)
    -> ExpandAndApplyResult<Func, FirstTypes..., Rest...> {
  return expandAndApplyWithIndexes(MakeIndexes<sizeof...(FirstTypes)>(),
      kj::fwd<Func>(func), first, kj::fwd<Rest>(rest)...);
}

template <typename Func, typename... FirstTypes, typename... Rest, size_t... indexes>
inline auto expandAndApplyWithIndexes(
    Indexes<indexes...>, Func&& func, Tuple<FirstTypes...>&& first, Rest&&... rest)
    -> ExpandAndApplyResult<Func, FirstTypes&&..., Rest...> {
  return expandAndApply(kj::fwd<Func>(func), kj::mv(getImpl<indexes>(first))...,
                        kj::fwd<Rest>(rest)...);
}

template <typename Func, typename... FirstTypes, typename... Rest, size_t... indexes>
inline auto expandAndApplyWithIndexes(
    Indexes<indexes...>, Func&& func, const Tuple<FirstTypes...>& first, Rest&&... rest)
    -> ExpandAndApplyResult<Func, FirstTypes..., Rest...> {
  return expandAndApply(kj::fwd<Func>(func), getImpl<indexes>(first)...,
                       kj::fwd<Rest>(rest)...);
}

struct MakeTupleFunc {
  template <typename... Params>
  Tuple<Decay<Params>...> operator()(Params&&... params) {
    return Tuple<Decay<Params>...>(kj::fwd<Params>(params)...);
  }
  template <typename Param>
  Decay<Param> operator()(Param&& param) {
    return kj::fwd<Param>(param);
  }
};

}

template <typename... T> struct Tuple_ { typedef _::Tuple<T...> Type; };
template <typename T> struct Tuple_<T> { typedef T Type; };

template <typename... T> using Tuple = typename Tuple_<T...>::Type;
# 331 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/tuple.h" 3
template <typename... Params>
inline auto tuple(Params&&... params)
    -> decltype(_::expandAndApply(_::MakeTupleFunc(), kj::fwd<Params>(params)...)) {


  return _::expandAndApply(_::MakeTupleFunc(), kj::fwd<Params>(params)...);
}

template <size_t index, typename Tuple>
inline auto get(Tuple&& tuple) -> decltype(_::getImpl<index>(kj::fwd<Tuple>(tuple))) {


  return _::getImpl<index>(kj::fwd<Tuple>(tuple));
}

template <typename Func, typename... Params>
inline auto apply(Func&& func, Params&&... params)
    -> decltype(_::expandAndApply(kj::fwd<Func>(func), kj::fwd<Params>(params)...)) {

  return _::expandAndApply(kj::fwd<Func>(func), kj::fwd<Params>(params)...);
}

template <typename T> struct TupleSize_ { static constexpr size_t size = 1; };
template <typename... T> struct TupleSize_<_::Tuple<T...>> {
  static constexpr size_t size = sizeof...(T);
};

template <typename T>
constexpr size_t tupleSize() { return TupleSize_<T>::size; }


}
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-prelude.h" 2 3

namespace kj {

class EventLoop;
template <typename T>
class Promise;
class WaitScope;

template <typename T>
Promise<Array<T>> joinPromises(Array<Promise<T>>&& promises);
Promise<void> joinPromises(Array<Promise<void>>&& promises);

namespace _ {

template <typename T> struct JoinPromises_ { typedef T Type; };
template <typename T> struct JoinPromises_<Promise<T>> { typedef T Type; };

template <typename T>
using JoinPromises = typename JoinPromises_<T>::Type;





class PropagateException {


public:
  class Bottom {
  public:
    Bottom(Exception&& exception): exception(kj::mv(exception)) {}

    Exception asException() { return kj::mv(exception); }

  private:
    Exception exception;
  };

  Bottom operator()(Exception&& e) {
    return Bottom(kj::mv(e));
  }
  Bottom operator()(const Exception& e) {
    return Bottom(kj::cp(e));
  }
};

template <typename Func, typename T>
struct ReturnType_ { typedef decltype(instance<Func>()(instance<T>())) Type; };
template <typename Func>
struct ReturnType_<Func, void> { typedef decltype(instance<Func>()()) Type; };

template <typename Func, typename T>
using ReturnType = typename ReturnType_<Func, T>::Type;



template <typename T> struct SplitTuplePromise_ { typedef Promise<T> Type; };
template <typename... T>
struct SplitTuplePromise_<kj::_::Tuple<T...>> {
  typedef kj::Tuple<Promise<JoinPromises<T>>...> Type;
};

template <typename T>
using SplitTuplePromise = typename SplitTuplePromise_<T>::Type;



struct Void {};


template <typename T> struct FixVoid_ { typedef T Type; };
template <> struct FixVoid_<void> { typedef Void Type; };
template <typename T> using FixVoid = typename FixVoid_<T>::Type;


template <typename T> struct UnfixVoid_ { typedef T Type; };
template <> struct UnfixVoid_<Void> { typedef void Type; };
template <typename T> using UnfixVoid = typename UnfixVoid_<T>::Type;


template <typename In, typename Out>
struct MaybeVoidCaller {



  template <typename Func>
  static inline Out apply(Func& func, In&& in) {
    return func(kj::mv(in));
  }
};
template <typename In, typename Out>
struct MaybeVoidCaller<In&, Out> {
  template <typename Func>
  static inline Out apply(Func& func, In& in) {
    return func(in);
  }
};
template <typename Out>
struct MaybeVoidCaller<Void, Out> {
  template <typename Func>
  static inline Out apply(Func& func, Void&& in) {
    return func();
  }
};
template <typename In>
struct MaybeVoidCaller<In, Void> {
  template <typename Func>
  static inline Void apply(Func& func, In&& in) {
    func(kj::mv(in));
    return Void();
  }
};
template <typename In>
struct MaybeVoidCaller<In&, Void> {
  template <typename Func>
  static inline Void apply(Func& func, In& in) {
    func(in);
    return Void();
  }
};
template <>
struct MaybeVoidCaller<Void, Void> {
  template <typename Func>
  static inline Void apply(Func& func, Void&& in) {
    func();
    return Void();
  }
};

template <typename T>
inline T&& returnMaybeVoid(T&& t) {
  return kj::fwd<T>(t);
}
inline void returnMaybeVoid(Void&& v) {}

class ExceptionOrValue;
class PromiseNode;
class ChainPromiseNode;
template <typename T>
class ForkHub;

class TaskSetImpl;

class Event;

class PromiseBase {
public:
  kj::String trace();


private:
  Own<PromiseNode> node;

  PromiseBase() = default;
  PromiseBase(Own<PromiseNode>&& node): node(kj::mv(node)) {}

  friend class kj::EventLoop;
  friend class ChainPromiseNode;
  template <typename>
  friend class kj::Promise;
  friend class TaskSetImpl;
  template <typename U>
  friend Promise<Array<U>> kj::joinPromises(Array<Promise<U>>&& promises);
  friend Promise<void> kj::joinPromises(Array<Promise<void>>&& promises);
};

void detach(kj::Promise<void>&& promise);
void waitImpl(Own<_::PromiseNode>&& node, _::ExceptionOrValue& result, WaitScope& waitScope);
Promise<void> yield();
Own<PromiseNode> neverDone();

class NeverDone {
public:
  template <typename T>
  operator Promise<T>() const {
    return Promise<T>(false, neverDone());
  }

  void wait(WaitScope& waitScope) const __attribute__((noreturn));
};

}
}
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/refcount.h" 1 3
# 25 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/refcount.h" 3
#define KJ_REFCOUNT_H_ 
# 29 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/refcount.h" 3


namespace kj {

class Refcounted: private Disposer {
# 59 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/refcount.h" 3
public:
  virtual ~Refcounted() noexcept(false);

  inline bool isShared() const { return refcount > 1; }



private:
  mutable uint refcount = 0;


  void disposeImpl(void* pointer) const override;
  template <typename T>
  static Own<T> addRefInternal(T* object);

  template <typename T>
  friend Own<T> addRef(T& object);
  template <typename T, typename... Params>
  friend Own<T> refcounted(Params&&... params);
};

template <typename T, typename... Params>
inline Own<T> refcounted(Params&&... params) {



  return Refcounted::addRefInternal(new T(kj::fwd<Params>(params)...));
}

template <typename T>
Own<T> addRef(T& object) {




                                                                                             ;
  return Refcounted::addRefInternal(&object);
}

template <typename T>
Own<T> Refcounted::addRefInternal(T* object) {
  Refcounted* refcounted = object;
  ++refcounted->refcount;
  return Own<T>(object, *refcounted);
}

}
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 2 3

namespace kj {

class EventLoop;
class WaitScope;

template <typename T>
class Promise;
template <typename T>
class ForkedPromise;
template <typename T>
class PromiseFulfiller;
template <typename T>
struct PromiseFulfillerPair;

template <typename Func, typename T>
using PromiseForResult = Promise<_::JoinPromises<_::ReturnType<Func, T>>>;







template <typename T>
class Promise: protected _::PromiseBase {
# 126 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
public:
  Promise(_::FixVoid<T> value);






  Promise(kj::Exception&& e);


  inline Promise(decltype(nullptr)) {}

  template <typename Func, typename ErrorFunc = _::PropagateException>
  PromiseForResult<Func, T> then(Func&& func, ErrorFunc&& errorHandler = _::PropagateException())
      __attribute__((warn_unused_result));
# 196 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  Promise<void> ignoreResult() __attribute__((warn_unused_result)) { return then([](T&&) {}); }




  template <typename ErrorFunc>
  Promise<T> catch_(ErrorFunc&& errorHandler) __attribute__((warn_unused_result));



  T wait(WaitScope& waitScope);
# 238 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  ForkedPromise<T> fork() __attribute__((warn_unused_result));





  _::SplitTuplePromise<T> split();





  Promise<T> exclusiveJoin(Promise<T>&& other) __attribute__((warn_unused_result));






  template <typename... Attachments>
  Promise<T> attach(Attachments&&... attachments) __attribute__((warn_unused_result));





  template <typename ErrorFunc>
  Promise<T> eagerlyEvaluate(ErrorFunc&& errorHandler) __attribute__((warn_unused_result));
  Promise<T> eagerlyEvaluate(decltype(nullptr)) __attribute__((warn_unused_result));
# 277 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  template <typename ErrorFunc>
  void detach(ErrorFunc&& errorHandler);
# 290 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  kj::String trace();



private:
  Promise(bool, Own<_::PromiseNode>&& node): PromiseBase(kj::mv(node)) {}


  template <typename>
  friend class Promise;
  friend class EventLoop;
  template <typename U, typename Adapter, typename... Params>
  friend Promise<U> newAdaptedPromise(Params&&... adapterConstructorParams);
  template <typename U>
  friend PromiseFulfillerPair<U> newPromiseAndFulfiller();
  template <typename>
  friend class _::ForkHub;
  friend class _::TaskSetImpl;
  friend Promise<void> _::yield();
  friend class _::NeverDone;
  template <typename U>
  friend Promise<Array<U>> joinPromises(Array<Promise<U>>&& promises);
  friend Promise<void> joinPromises(Array<Promise<void>>&& promises);
};

template <typename T>
class ForkedPromise {



public:
  inline ForkedPromise(decltype(nullptr)) {}

  Promise<T> addBranch();


private:
  Own<_::ForkHub<_::FixVoid<T>>> hub;

  inline ForkedPromise(bool, Own<_::ForkHub<_::FixVoid<T>>>&& hub): hub(kj::mv(hub)) {}

  friend class Promise<T>;
  friend class EventLoop;
};

constexpr _::Void READY_NOW = _::Void();



constexpr _::NeverDone NEVER_DONE = _::NeverDone();




template <typename Func>
PromiseForResult<Func, void> evalLater(Func&& func) __attribute__((warn_unused_result));
# 362 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
template <typename Func>
PromiseForResult<Func, void> evalNow(Func&& func) __attribute__((warn_unused_result));




template <typename T>
Promise<Array<T>> joinPromises(Array<Promise<T>>&& promises);





template <typename Func, typename MovedParam>
class CaptureByMove {
public:
  inline CaptureByMove(Func&& func, MovedParam&& param)
      : func(kj::mv(func)), param(kj::mv(param)) {}

  template <typename... Params>
  inline auto operator()(Params&&... params)
      -> decltype(kj::instance<Func>()(kj::instance<MovedParam&&>(), kj::fwd<Params>(params)...)) {
    return func(kj::mv(param), kj::fwd<Params>(params)...);
  }

private:
  Func func;
  MovedParam param;
};

template <typename Func, typename MovedParam>
inline CaptureByMove<Func, Decay<MovedParam>> mvCapture(MovedParam&& param, Func&& func) {
# 404 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  return CaptureByMove<Func, Decay<MovedParam>>(kj::fwd<Func>(func), kj::mv(param));
}




template <typename T>
class PromiseFulfiller {



public:
  virtual void fulfill(T&& value) = 0;


  virtual void reject(Exception&& exception) = 0;


  virtual bool isWaiting() = 0;




  template <typename Func>
  bool rejectIfThrows(Func&& func);



};

template <>
class PromiseFulfiller<void> {


public:
  virtual void fulfill(_::Void&& value = _::Void()) = 0;



  virtual void reject(Exception&& exception) = 0;
  virtual bool isWaiting() = 0;

  template <typename Func>
  bool rejectIfThrows(Func&& func);
};

template <typename T, typename Adapter, typename... Params>
Promise<T> newAdaptedPromise(Params&&... adapterConstructorParams);
# 471 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
template <typename T>
struct PromiseFulfillerPair {
  Promise<_::JoinPromises<T>> promise;
  Own<PromiseFulfiller<T>> fulfiller;
};

template <typename T>
PromiseFulfillerPair<T> newPromiseAndFulfiller();
# 494 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
class TaskSet {
# 505 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
public:
  class ErrorHandler {
  public:
    virtual void taskFailed(kj::Exception&& exception) = 0;
  };

  TaskSet(ErrorHandler& errorHandler);



  ~TaskSet() noexcept(false);

  void add(Promise<void>&& promise);

  kj::String trace();


private:
  Own<_::TaskSetImpl> impl;
};




class EventPort {







public:
  virtual bool wait() = 0;
# 552 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  virtual bool poll() = 0;
# 563 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
  virtual void setRunnable(bool runnable);





  virtual void wake() const;
# 579 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
};

class EventLoop {
# 613 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
public:
  EventLoop();


  explicit EventLoop(EventPort& port);


  ~EventLoop() noexcept(false);

  void run(uint maxTurnCount = maxValue);




  bool isRunnable();


private:
  EventPort& port;

  bool running = false;


  bool lastRunnableState = false;


  _::Event* head = nullptr;
  _::Event** tail = &head;
  _::Event** depthFirstInsertPoint = &head;

  Own<_::TaskSetImpl> daemons;

  bool turn();
  void setRunnable(bool runnable);
  void enterScope();
  void leaveScope();

  friend void _::detach(kj::Promise<void>&& promise);
  friend void _::waitImpl(Own<_::PromiseNode>&& node, _::ExceptionOrValue& result,
                          WaitScope& waitScope);
  friend class _::Event;
  friend class WaitScope;
};

class WaitScope {
# 666 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 3
public:
  inline explicit WaitScope(EventLoop& loop): loop(loop) { loop.enterScope(); }
  inline ~WaitScope() { loop.leaveScope(); }
  WaitScope(const WaitScope&) = delete; WaitScope& operator=(const WaitScope&) = delete;

private:
  EventLoop& loop;
  friend class EventLoop;
  friend void _::waitImpl(Own<_::PromiseNode>&& node, _::ExceptionOrValue& result,
                          WaitScope& waitScope);
};

}


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 1 3
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 3
#define KJ_ASYNC_INL_H_ 
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 3


namespace kj {
namespace _ {

template <typename T>
class ExceptionOr;

class ExceptionOrValue {
public:
  ExceptionOrValue(bool, Exception&& exception): exception(kj::mv(exception)) {}
  ExceptionOrValue(const ExceptionOrValue&) = delete; ExceptionOrValue& operator=(const ExceptionOrValue&) = delete;

  void addException(Exception&& exception) {
    if (this->exception == nullptr) {
      this->exception = kj::mv(exception);
    }
  }

  template <typename T>
  ExceptionOr<T>& as() { return *static_cast<ExceptionOr<T>*>(this); }
  template <typename T>
  const ExceptionOr<T>& as() const { return *static_cast<const ExceptionOr<T>*>(this); }

  Maybe<Exception> exception;

protected:

  ExceptionOrValue() = default;
  ExceptionOrValue(ExceptionOrValue&& other) = default;
  ExceptionOrValue& operator=(ExceptionOrValue&& other) = default;
};

template <typename T>
class ExceptionOr: public ExceptionOrValue {
public:
  ExceptionOr() = default;
  ExceptionOr(T&& value): value(kj::mv(value)) {}
  ExceptionOr(bool, Exception&& exception): ExceptionOrValue(false, kj::mv(exception)) {}
  ExceptionOr(ExceptionOr&&) = default;
  ExceptionOr& operator=(ExceptionOr&&) = default;

  Maybe<T> value;
};

class Event {



public:
  Event();
  ~Event() noexcept(false);
  Event(const Event&) = delete; Event& operator=(const Event&) = delete;

  void armDepthFirst();
# 106 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 3
  void armBreadthFirst();


  kj::String trace();


  virtual _::PromiseNode* getInnerForTrace();



protected:
  virtual Maybe<Own<Event>> fire() = 0;




private:
  friend class kj::EventLoop;
  EventLoop& loop;
  Event* next;
  Event** prev;
  bool firing = false;
};

class PromiseNode {







public:
  virtual void onReady(Event& event) noexcept = 0;


  virtual void setSelfPointer(Own<PromiseNode>* selfPtr) noexcept;





  virtual void get(ExceptionOrValue& output) noexcept = 0;




  virtual PromiseNode* getInnerForTrace();



protected:
  class OnReadyEvent {


  public:
    void init(Event& newEvent);


    void arm();



  private:
    Event* event = nullptr;
  };
};



class ImmediatePromiseNodeBase: public PromiseNode {
public:
  ImmediatePromiseNodeBase();
  ~ImmediatePromiseNodeBase() noexcept(false);

  void onReady(Event& event) noexcept override;
};

template <typename T>
class ImmediatePromiseNode final: public ImmediatePromiseNodeBase {


public:
  ImmediatePromiseNode(ExceptionOr<T>&& result): result(kj::mv(result)) {}

  void get(ExceptionOrValue& output) noexcept override {
    output.as<T>() = kj::mv(result);
  }

private:
  ExceptionOr<T> result;
};

class ImmediateBrokenPromiseNode final: public ImmediatePromiseNodeBase {
public:
  ImmediateBrokenPromiseNode(Exception&& exception);

  void get(ExceptionOrValue& output) noexcept override;

private:
  Exception exception;
};



class AttachmentPromiseNodeBase: public PromiseNode {
public:
  AttachmentPromiseNodeBase(Own<PromiseNode>&& dependency);

  void onReady(Event& event) noexcept override;
  void get(ExceptionOrValue& output) noexcept override;
  PromiseNode* getInnerForTrace() override;

private:
  Own<PromiseNode> dependency;

  void dropDependency();

  template <typename>
  friend class AttachmentPromiseNode;
};

template <typename Attachment>
class AttachmentPromiseNode final: public AttachmentPromiseNodeBase {



public:
  AttachmentPromiseNode(Own<PromiseNode>&& dependency, Attachment&& attachment)
      : AttachmentPromiseNodeBase(kj::mv(dependency)),
        attachment(kj::mv<Attachment>(attachment)) {}

  ~AttachmentPromiseNode() noexcept(false) {


    dropDependency();
  }

private:
  Attachment attachment;
};



class PtmfHelper {



  template <typename... ParamTypes>
  friend struct GetFunctorStartAddress;



  void* ptr;
  ptrdiff_t adj;


  void* apply(void* obj) {

    if (adj & 1) {
      ptrdiff_t voff = (ptrdiff_t)ptr;





      return *(void**)(*(char**)obj + voff);
    } else {
      return ptr;
    }
  }

#define BODY PtmfHelper result; static_assert(sizeof(p) == sizeof(result), "unknown ptmf layout"); memcpy(&result, &p, sizeof(result)); return result
# 293 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 3
 template <typename R, typename C, typename... P, typename F>
  static PtmfHelper from(F p) { PtmfHelper result; static_assert(sizeof(p) == sizeof(result), "unknown ptmf layout"); memcpy(&result, &p, sizeof(result)); return result; }




  template <typename R, typename C, typename... P>
  static PtmfHelper from(R (C::*p)(NoInfer<P>...)) { PtmfHelper result; static_assert(sizeof(p) == sizeof(result), "unknown ptmf layout"); memcpy(&result, &p, sizeof(result)); return result; }
  template <typename R, typename C, typename... P>
  static PtmfHelper from(R (C::*p)(NoInfer<P>...) const) { PtmfHelper result; static_assert(sizeof(p) == sizeof(result), "unknown ptmf layout"); memcpy(&result, &p, sizeof(result)); return result; }





#undef BODY
};

template <typename... ParamTypes>
struct GetFunctorStartAddress {
# 324 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 3
  template <typename Func>
  static void* apply(Func&& func) {
    typedef decltype(func(instance<ParamTypes>()...)) ReturnType;
    return PtmfHelper::from<ReturnType, Decay<Func>, ParamTypes...>(
        &Decay<Func>::operator()).apply(&func);
  }
};

template <>
struct GetFunctorStartAddress<Void&&>: public GetFunctorStartAddress<> {};



class TransformPromiseNodeBase: public PromiseNode {
public:
  TransformPromiseNodeBase(Own<PromiseNode>&& dependency, void* continuationTracePtr);

  void onReady(Event& event) noexcept override;
  void get(ExceptionOrValue& output) noexcept override;
  PromiseNode* getInnerForTrace() override;

private:
  Own<PromiseNode> dependency;
  void* continuationTracePtr;

  void dropDependency();
  void getDepResult(ExceptionOrValue& output);

  virtual void getImpl(ExceptionOrValue& output) = 0;

  template <typename, typename, typename, typename>
  friend class TransformPromiseNode;
};

template <typename T, typename DepT, typename Func, typename ErrorFunc>
class TransformPromiseNode final: public TransformPromiseNodeBase {



public:
  TransformPromiseNode(Own<PromiseNode>&& dependency, Func&& func, ErrorFunc&& errorHandler)
      : TransformPromiseNodeBase(kj::mv(dependency),
            GetFunctorStartAddress<DepT&&>::apply(func)),
        func(kj::fwd<Func>(func)), errorHandler(kj::fwd<ErrorFunc>(errorHandler)) {}

  ~TransformPromiseNode() noexcept(false) {



    dropDependency();
  }

private:
  Func func;
  ErrorFunc errorHandler;

  void getImpl(ExceptionOrValue& output) override {
    ExceptionOr<DepT> depResult;
    getDepResult(depResult);
    if (auto depException = ::kj::_::readMaybe(depResult.exception)) {
      output.as<T>() = handle(
          MaybeVoidCaller<Exception, FixVoid<ReturnType<ErrorFunc, Exception>>>::apply(
              errorHandler, kj::mv(*depException)));
    } else if (auto depValue = ::kj::_::readMaybe(depResult.value)) {
      output.as<T>() = handle(MaybeVoidCaller<DepT, T>::apply(func, kj::mv(*depValue)));
    }
  }

  ExceptionOr<T> handle(T&& value) {
    return kj::mv(value);
  }
  ExceptionOr<T> handle(PropagateException::Bottom&& value) {
    return ExceptionOr<T>(false, value.asException());
  }
};



class ForkHubBase;

class ForkBranchBase: public PromiseNode {
public:
  ForkBranchBase(Own<ForkHubBase>&& hub);
  ~ForkBranchBase() noexcept(false);

  void hubReady() noexcept;



  void onReady(Event& event) noexcept override;
  PromiseNode* getInnerForTrace() override;

protected:
  inline ExceptionOrValue& getHubResultRef();

  void releaseHub(ExceptionOrValue& output);


private:
  OnReadyEvent onReadyEvent;

  Own<ForkHubBase> hub;
  ForkBranchBase* next = nullptr;
  ForkBranchBase** prevPtr = nullptr;

  friend class ForkHubBase;
};

template <typename T> T copyOrAddRef(T& t) { return t; }
template <typename T> Own<T> copyOrAddRef(Own<T>& t) { return t->addRef(); }

template <typename T>
class ForkBranch final: public ForkBranchBase {



public:
  ForkBranch(Own<ForkHubBase>&& hub): ForkBranchBase(kj::mv(hub)) {}

  void get(ExceptionOrValue& output) noexcept override {
    ExceptionOr<T>& hubResult = getHubResultRef().template as<T>();
    if (auto value = ::kj::_::readMaybe(hubResult.value)) {
      output.as<T>().value = copyOrAddRef(*value);
    } else {
      output.as<T>().value = nullptr;
    }
    output.exception = hubResult.exception;
    releaseHub(output);
  }
};

template <typename T, size_t index>
class SplitBranch final: public ForkBranchBase {



public:
  SplitBranch(Own<ForkHubBase>&& hub): ForkBranchBase(kj::mv(hub)) {}

  typedef kj::Decay<decltype(kj::get<index>(kj::instance<T>()))> Element;

  void get(ExceptionOrValue& output) noexcept override {
    ExceptionOr<T>& hubResult = getHubResultRef().template as<T>();
    if (auto value = ::kj::_::readMaybe(hubResult.value)) {
      output.as<Element>().value = kj::mv(kj::get<index>(*value));
    } else {
      output.as<Element>().value = nullptr;
    }
    output.exception = hubResult.exception;
    releaseHub(output);
  }
};



class ForkHubBase: public Refcounted, protected Event {
public:
  ForkHubBase(Own<PromiseNode>&& inner, ExceptionOrValue& resultRef);

  inline ExceptionOrValue& getResultRef() { return resultRef; }

private:
  Own<PromiseNode> inner;
  ExceptionOrValue& resultRef;

  ForkBranchBase* headBranch = nullptr;
  ForkBranchBase** tailBranch = &headBranch;


  Maybe<Own<Event>> fire() override;
  _::PromiseNode* getInnerForTrace() override;

  friend class ForkBranchBase;
};

template <typename T>
class ForkHub final: public ForkHubBase {




public:
  ForkHub(Own<PromiseNode>&& inner): ForkHubBase(kj::mv(inner), result) {}

  Promise<_::UnfixVoid<T>> addBranch() {
    return Promise<_::UnfixVoid<T>>(false, kj::heap<ForkBranch<T>>(addRef(*this)));
  }

  _::SplitTuplePromise<T> split() {
    return splitImpl(MakeIndexes<tupleSize<T>()>());
  }

private:
  ExceptionOr<T> result;

  template <size_t... indexes>
  _::SplitTuplePromise<T> splitImpl(Indexes<indexes...>) {
    return kj::tuple(addSplit<indexes>()...);
  }

  template <size_t index>
  Promise<JoinPromises<typename SplitBranch<T, index>::Element>> addSplit() {
    return Promise<JoinPromises<typename SplitBranch<T, index>::Element>>(
        false, maybeChain(kj::heap<SplitBranch<T, index>>(addRef(*this)),
                          implicitCast<typename SplitBranch<T, index>::Element*>(nullptr)));
  }
};

inline ExceptionOrValue& ForkBranchBase::getHubResultRef() {
  return hub->getResultRef();
}



class ChainPromiseNode final: public PromiseNode, public Event {





public:
  explicit ChainPromiseNode(Own<PromiseNode> inner);
  ~ChainPromiseNode() noexcept(false);

  void onReady(Event& event) noexcept override;
  void setSelfPointer(Own<PromiseNode>* selfPtr) noexcept override;
  void get(ExceptionOrValue& output) noexcept override;
  PromiseNode* getInnerForTrace() override;

private:
  enum State {
    STEP1,
    STEP2
  };

  State state;

  Own<PromiseNode> inner;



  Event* onReadyEvent = nullptr;
  Own<PromiseNode>* selfPtr = nullptr;

  Maybe<Own<Event>> fire() override;
};

template <typename T>
Own<PromiseNode> maybeChain(Own<PromiseNode>&& node, Promise<T>*) {
  return heap<ChainPromiseNode>(kj::mv(node));
}

template <typename T>
Own<PromiseNode>&& maybeChain(Own<PromiseNode>&& node, T*) {
  return kj::mv(node);
}



class ExclusiveJoinPromiseNode final: public PromiseNode {
public:
  ExclusiveJoinPromiseNode(Own<PromiseNode> left, Own<PromiseNode> right);
  ~ExclusiveJoinPromiseNode() noexcept(false);

  void onReady(Event& event) noexcept override;
  void get(ExceptionOrValue& output) noexcept override;
  PromiseNode* getInnerForTrace() override;

private:
  class Branch: public Event {
  public:
    Branch(ExclusiveJoinPromiseNode& joinNode, Own<PromiseNode> dependency);
    ~Branch() noexcept(false);

    bool get(ExceptionOrValue& output);


    Maybe<Own<Event>> fire() override;
    _::PromiseNode* getInnerForTrace() override;

  private:
    ExclusiveJoinPromiseNode& joinNode;
    Own<PromiseNode> dependency;
  };

  Branch left;
  Branch right;
  OnReadyEvent onReadyEvent;
};



class ArrayJoinPromiseNodeBase: public PromiseNode {
public:
  ArrayJoinPromiseNodeBase(Array<Own<PromiseNode>> promises,
                           ExceptionOrValue* resultParts, size_t partSize);
  ~ArrayJoinPromiseNodeBase() noexcept(false);

  void onReady(Event& event) noexcept override final;
  void get(ExceptionOrValue& output) noexcept override final;
  PromiseNode* getInnerForTrace() override final;

protected:
  virtual void getNoError(ExceptionOrValue& output) noexcept = 0;


private:
  uint countLeft;
  OnReadyEvent onReadyEvent;

  class Branch final: public Event {
  public:
    Branch(ArrayJoinPromiseNodeBase& joinNode, Own<PromiseNode> dependency,
           ExceptionOrValue& output);
    ~Branch() noexcept(false);

    Maybe<Own<Event>> fire() override;
    _::PromiseNode* getInnerForTrace() override;

    Maybe<Exception> getPart();


  private:
    ArrayJoinPromiseNodeBase& joinNode;
    Own<PromiseNode> dependency;
    ExceptionOrValue& output;
  };

  Array<Branch> branches;
};

template <typename T>
class ArrayJoinPromiseNode final: public ArrayJoinPromiseNodeBase {
public:
  ArrayJoinPromiseNode(Array<Own<PromiseNode>> promises,
                       Array<ExceptionOr<T>> resultParts)
      : ArrayJoinPromiseNodeBase(kj::mv(promises), resultParts.begin(), sizeof(ExceptionOr<T>)),
        resultParts(kj::mv(resultParts)) {}

protected:
  void getNoError(ExceptionOrValue& output) noexcept override {
    auto builder = heapArrayBuilder<T>(resultParts.size());
    for (auto& part: resultParts) {

                                                                                                ;
      builder.add(kj::mv(*_::readMaybe(part.value)));
    }
    output.as<Array<T>>() = builder.finish();
  }

private:
  Array<ExceptionOr<T>> resultParts;
};

template <>
class ArrayJoinPromiseNode<void> final: public ArrayJoinPromiseNodeBase {
public:
  ArrayJoinPromiseNode(Array<Own<PromiseNode>> promises,
                       Array<ExceptionOr<_::Void>> resultParts);
  ~ArrayJoinPromiseNode();

protected:
  void getNoError(ExceptionOrValue& output) noexcept override;

private:
  Array<ExceptionOr<_::Void>> resultParts;
};



class EagerPromiseNodeBase: public PromiseNode, protected Event {



public:
  EagerPromiseNodeBase(Own<PromiseNode>&& dependency, ExceptionOrValue& resultRef);

  void onReady(Event& event) noexcept override;
  PromiseNode* getInnerForTrace() override;

private:
  Own<PromiseNode> dependency;
  OnReadyEvent onReadyEvent;

  ExceptionOrValue& resultRef;

  Maybe<Own<Event>> fire() override;
};

template <typename T>
class EagerPromiseNode final: public EagerPromiseNodeBase {
public:
  EagerPromiseNode(Own<PromiseNode>&& dependency)
      : EagerPromiseNodeBase(kj::mv(dependency), result) {}

  void get(ExceptionOrValue& output) noexcept override {
    output.as<T>() = kj::mv(result);
  }

private:
  ExceptionOr<T> result;
};

template <typename T>
Own<PromiseNode> spark(Own<PromiseNode>&& node) {


  return heap<EagerPromiseNode<T>>(kj::mv(node));
}



class AdapterPromiseNodeBase: public PromiseNode {
public:
  void onReady(Event& event) noexcept override;

protected:
  inline void setReady() {
    onReadyEvent.arm();
  }

private:
  OnReadyEvent onReadyEvent;
};

template <typename T, typename Adapter>
class AdapterPromiseNode final: public AdapterPromiseNodeBase,
                                private PromiseFulfiller<UnfixVoid<T>> {


public:
  template <typename... Params>
  AdapterPromiseNode(Params&&... params)
      : adapter(static_cast<PromiseFulfiller<UnfixVoid<T>>&>(*this), kj::fwd<Params>(params)...) {}

  void get(ExceptionOrValue& output) noexcept override {
                             ;
    output.as<T>() = kj::mv(result);
  }

private:
  ExceptionOr<T> result;
  bool waiting = true;
  Adapter adapter;

  void fulfill(T&& value) override {
    if (waiting) {
      waiting = false;
      result = ExceptionOr<T>(kj::mv(value));
      setReady();
    }
  }

  void reject(Exception&& exception) override {
    if (waiting) {
      waiting = false;
      result = ExceptionOr<T>(false, kj::mv(exception));
      setReady();
    }
  }

  bool isWaiting() override {
    return waiting;
  }
};

}



template <typename T>
Promise<T>::Promise(_::FixVoid<T> value)
    : PromiseBase(heap<_::ImmediatePromiseNode<_::FixVoid<T>>>(kj::mv(value))) {}

template <typename T>
Promise<T>::Promise(kj::Exception&& exception)
    : PromiseBase(heap<_::ImmediateBrokenPromiseNode>(kj::mv(exception))) {}

template <typename T>
template <typename Func, typename ErrorFunc>
PromiseForResult<Func, T> Promise<T>::then(Func&& func, ErrorFunc&& errorHandler) {
  typedef _::FixVoid<_::ReturnType<Func, T>> ResultT;

  Own<_::PromiseNode> intermediate =
      heap<_::TransformPromiseNode<ResultT, _::FixVoid<T>, Func, ErrorFunc>>(
          kj::mv(node), kj::fwd<Func>(func), kj::fwd<ErrorFunc>(errorHandler));
  return PromiseForResult<Func, T>(false,
      _::maybeChain(kj::mv(intermediate), implicitCast<ResultT*>(nullptr)));
}

namespace _ {

template <typename T>
struct IdentityFunc {
  inline T operator()(T&& value) const {
    return kj::mv(value);
  }
};
template <typename T>
struct IdentityFunc<Promise<T>> {
  inline Promise<T> operator()(T&& value) const {
    return kj::mv(value);
  }
};
template <>
struct IdentityFunc<void> {
  inline void operator()() const {}
};
template <>
struct IdentityFunc<Promise<void>> {
  Promise<void> operator()() const;



};

}

template <typename T>
template <typename ErrorFunc>
Promise<T> Promise<T>::catch_(ErrorFunc&& errorHandler) {




  return then(_::IdentityFunc<decltype(errorHandler(instance<Exception&&>()))>(),
              kj::fwd<ErrorFunc>(errorHandler));
}

template <typename T>
T Promise<T>::wait(WaitScope& waitScope) {
  _::ExceptionOr<_::FixVoid<T>> result;

  waitImpl(kj::mv(node), result, waitScope);

  if (auto value = ::kj::_::readMaybe(result.value)) {
    if (auto exception = ::kj::_::readMaybe(result.exception)) {
      throwRecoverableException(kj::mv(*exception));
    }
    return _::returnMaybeVoid(kj::mv(*value));
  } else if (auto exception = ::kj::_::readMaybe(result.exception)) {
    throwFatalException(kj::mv(*exception));
  } else {

    ::kj::_::unreachable();;
  }
}

template <>
inline void Promise<void>::wait(WaitScope& waitScope) {


  _::ExceptionOr<_::Void> result;

  waitImpl(kj::mv(node), result, waitScope);

  if (result.value != nullptr) {
    if (auto exception = ::kj::_::readMaybe(result.exception)) {
      throwRecoverableException(kj::mv(*exception));
    }
  } else if (auto exception = ::kj::_::readMaybe(result.exception)) {
    throwRecoverableException(kj::mv(*exception));
  } else {

    ::kj::_::unreachable();;
  }
}

template <typename T>
ForkedPromise<T> Promise<T>::fork() {
  return ForkedPromise<T>(false, refcounted<_::ForkHub<_::FixVoid<T>>>(kj::mv(node)));
}

template <typename T>
Promise<T> ForkedPromise<T>::addBranch() {
  return hub->addBranch();
}

template <typename T>
_::SplitTuplePromise<T> Promise<T>::split() {
  return refcounted<_::ForkHub<_::FixVoid<T>>>(kj::mv(node))->split();
}

template <typename T>
Promise<T> Promise<T>::exclusiveJoin(Promise<T>&& other) {
  return Promise(false, heap<_::ExclusiveJoinPromiseNode>(kj::mv(node), kj::mv(other.node)));
}

template <typename T>
template <typename... Attachments>
Promise<T> Promise<T>::attach(Attachments&&... attachments) {
  return Promise(false, kj::heap<_::AttachmentPromiseNode<Tuple<Attachments...>>>(
      kj::mv(node), kj::tuple(kj::fwd<Attachments>(attachments)...)));
}

template <typename T>
template <typename ErrorFunc>
Promise<T> Promise<T>::eagerlyEvaluate(ErrorFunc&& errorHandler) {

  return Promise(false, _::spark<_::FixVoid<T>>(then(
      _::IdentityFunc<decltype(errorHandler(instance<Exception&&>()))>(),
      kj::fwd<ErrorFunc>(errorHandler)).node));
}

template <typename T>
Promise<T> Promise<T>::eagerlyEvaluate(decltype(nullptr)) {
  return Promise(false, _::spark<_::FixVoid<T>>(kj::mv(node)));
}

template <typename T>
kj::String Promise<T>::trace() {
  return PromiseBase::trace();
}

template <typename Func>
inline PromiseForResult<Func, void> evalLater(Func&& func) {
  return _::yield().then(kj::fwd<Func>(func), _::PropagateException());
}

template <typename Func>
inline PromiseForResult<Func, void> evalNow(Func&& func) {
  PromiseForResult<Func, void> result = nullptr;
  if (auto e = ::kj::_::readMaybe(kj::runCatchingExceptions([&]() { result = func(); }))) {


    result = kj::mv(*e);
  }
  return result;
}

template <typename T>
template <typename ErrorFunc>
void Promise<T>::detach(ErrorFunc&& errorHandler) {
  return _::detach(then([](T&&) {}, kj::fwd<ErrorFunc>(errorHandler)));
}

template <>
template <typename ErrorFunc>
void Promise<void>::detach(ErrorFunc&& errorHandler) {
  return _::detach(then([]() {}, kj::fwd<ErrorFunc>(errorHandler)));
}

template <typename T>
Promise<Array<T>> joinPromises(Array<Promise<T>>&& promises) {
  return Promise<Array<T>>(false, kj::heap<_::ArrayJoinPromiseNode<T>>(
      ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(promises))>(promises) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(promises))>::Element p) { return kj::mv(p.node); },
      heapArray<_::ExceptionOr<T>>(promises.size())));
}



namespace _ {

template <typename T>
class WeakFulfiller final: public PromiseFulfiller<T>, private kj::Disposer {
# 992 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h" 3
public:
  WeakFulfiller(const WeakFulfiller&) = delete; WeakFulfiller& operator=(const WeakFulfiller&) = delete;

  static kj::Own<WeakFulfiller> make() {
    WeakFulfiller* ptr = new WeakFulfiller;
    return Own<WeakFulfiller>(ptr, *ptr);
  }

  void fulfill(FixVoid<T>&& value) override {
    if (inner != nullptr) {
      inner->fulfill(kj::mv(value));
    }
  }

  void reject(Exception&& exception) override {
    if (inner != nullptr) {
      inner->reject(kj::mv(exception));
    }
  }

  bool isWaiting() override {
    return inner != nullptr && inner->isWaiting();
  }

  void attach(PromiseFulfiller<T>& newInner) {
    inner = &newInner;
  }

  void detach(PromiseFulfiller<T>& from) {
    if (inner == nullptr) {

      delete this;
    } else {
                                 ;
      inner = nullptr;
    }
  }

private:
  mutable PromiseFulfiller<T>* inner;

  WeakFulfiller(): inner(nullptr) {}

  void disposeImpl(void* pointer) const override {


    if (inner == nullptr) {

      delete this;
    } else {
      if (inner->isWaiting()) {
        inner->reject(kj::Exception(kj::Exception::Type::FAILED, "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async-inl.h", 1043,
            kj::heapString("PromiseFulfiller was destroyed without fulfilling the promise.")));
      }
      inner = nullptr;
    }
  }
};

template <typename T>
class PromiseAndFulfillerAdapter {
public:
  PromiseAndFulfillerAdapter(PromiseFulfiller<T>& fulfiller,
                             WeakFulfiller<T>& wrapper)
      : fulfiller(fulfiller), wrapper(wrapper) {
    wrapper.attach(fulfiller);
  }

  ~PromiseAndFulfillerAdapter() noexcept(false) {
    wrapper.detach(fulfiller);
  }

private:
  PromiseFulfiller<T>& fulfiller;
  WeakFulfiller<T>& wrapper;
};

}

template <typename T>
template <typename Func>
bool PromiseFulfiller<T>::rejectIfThrows(Func&& func) {
  if (auto exception = ::kj::_::readMaybe(kj::runCatchingExceptions(kj::mv(func)))) {
    reject(kj::mv(*exception));
    return false;
  } else {
    return true;
  }
}

template <typename Func>
bool PromiseFulfiller<void>::rejectIfThrows(Func&& func) {
  if (auto exception = ::kj::_::readMaybe(kj::runCatchingExceptions(kj::mv(func)))) {
    reject(kj::mv(*exception));
    return false;
  } else {
    return true;
  }
}

template <typename T, typename Adapter, typename... Params>
Promise<T> newAdaptedPromise(Params&&... adapterConstructorParams) {
  return Promise<T>(false, heap<_::AdapterPromiseNode<_::FixVoid<T>, Adapter>>(
      kj::fwd<Params>(adapterConstructorParams)...));
}

template <typename T>
PromiseFulfillerPair<T> newPromiseAndFulfiller() {
  auto wrapper = _::WeakFulfiller<T>::make();

  Own<_::PromiseNode> intermediate(
      heap<_::AdapterPromiseNode<_::FixVoid<T>, _::PromiseAndFulfillerAdapter<T>>>(*wrapper));
  Promise<_::JoinPromises<T>> promise(false,
      _::maybeChain(kj::mv(intermediate), implicitCast<T*>(nullptr)));

  return PromiseFulfillerPair<T> { kj::mv(promise), kj::mv(wrapper) };
}

}
# 681 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/async.h" 2 3
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 2 3





namespace capnp {

template <typename Results>
class Response;

template <typename T>
class RemotePromise: public kj::Promise<Response<T>>, public T::Pipeline {
# 54 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
public:
  inline RemotePromise(kj::Promise<Response<T>>&& promise, typename T::Pipeline&& pipeline)
      : kj::Promise<Response<T>>(kj::mv(promise)),
        T::Pipeline(kj::mv(pipeline)) {}
  inline RemotePromise(decltype(nullptr))
      : kj::Promise<Response<T>>(nullptr),
        T::Pipeline(nullptr) {}
  RemotePromise(const RemotePromise&) = delete; RemotePromise& operator=(const RemotePromise&) = delete;
  RemotePromise(RemotePromise&& other) = default;
  RemotePromise& operator=(RemotePromise&& other) = default;
};

class LocalClient;
namespace _ {
extern const RawSchema NULL_INTERFACE_SCHEMA;
class CapabilityServerSetBase;
}

struct Capability {



  class Client;
  class Server;

  struct _capnpPrivate {
    struct IsInterface;
    static constexpr uint64_t typeId = 0x3;
    static constexpr Kind kind = Kind::INTERFACE;
    static constexpr _::RawSchema const* schema = &_::NULL_INTERFACE_SCHEMA;

    static const _::RawBrandedSchema* brand() {
      return &_::NULL_INTERFACE_SCHEMA.defaultBrand;
    }
  };
};




class RequestHook;
class ResponseHook;
class PipelineHook;
class ClientHook;

template <typename Params, typename Results>
class Request: public Params::Builder {







public:
  inline Request(typename Params::Builder builder, kj::Own<RequestHook>&& hook)
      : Params::Builder(builder), hook(kj::mv(hook)) {}
  inline Request(decltype(nullptr)): Params::Builder(nullptr) {}

  RemotePromise<Results> send() __attribute__((warn_unused_result));


private:
  kj::Own<RequestHook> hook;

  friend class Capability::Client;
  friend struct DynamicCapability;
  template <typename, typename>
  friend class CallContext;
  friend class RequestHook;
};

template <typename Results>
class Response: public Results::Reader {



public:
  inline Response(typename Results::Reader reader, kj::Own<ResponseHook>&& hook)
      : Results::Reader(reader), hook(kj::mv(hook)) {}

private:
  kj::Own<ResponseHook> hook;

  template <typename, typename>
  friend class Request;
  friend class ResponseHook;
};

class Capability::Client {


public:
  typedef Capability Reads;
  typedef Capability Calls;

  Client(decltype(nullptr));





  template <typename T, typename = kj::EnableIf<kj::canConvert<T*, Capability::Server*>()>>
  Client(kj::Own<T>&& server);



  template <typename T, typename = kj::EnableIf<kj::canConvert<T*, Client*>()>>
  Client(kj::Promise<T>&& promise);



  Client(kj::Exception&& exception);


  Client(Client& other);
  Client& operator=(Client& other);



  Client(Client&&) = default;
  Client& operator=(Client&&) = default;


  explicit Client(kj::Own<ClientHook>&& hook);


  template <typename T>
  typename T::Client castAs();







  template <typename T>
  typename T::Client castAs(InterfaceSchema schema);


  kj::Promise<void> whenResolved();






  Request<AnyPointer, AnyPointer> typelessRequest(
      uint64_t interfaceId, uint16_t methodId,
      kj::Maybe<MessageSize> sizeHint);





protected:
  Client() = default;

  template <typename Params, typename Results>
  Request<Params, Results> newCall(uint64_t interfaceId, uint16_t methodId,
                                   kj::Maybe<MessageSize> sizeHint);

private:
  kj::Own<ClientHook> hook;

  static kj::Own<ClientHook> makeLocalClient(kj::Own<Capability::Server>&& server);

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend struct DynamicCapability;
  friend class Orphanage;
  friend struct DynamicStruct;
  friend struct DynamicList;
  template <typename, Kind>
  friend struct List;
  friend class _::CapabilityServerSetBase;
  friend class ClientHook;
};




class CallContextHook;

template <typename Params, typename Results>
class CallContext: public kj::DisallowConstCopy {







public:
  explicit CallContext(CallContextHook& hook);

  typename Params::Reader getParams();


  void releaseParams();





  typename Results::Builder getResults(kj::Maybe<MessageSize> sizeHint = nullptr);
  typename Results::Builder initResults(kj::Maybe<MessageSize> sizeHint = nullptr);
  void setResults(typename Results::Reader value);
  void adoptResults(Orphan<Results>&& value);
  Orphanage getResultsOrphanage(kj::Maybe<MessageSize> sizeHint = nullptr);
# 276 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
  template <typename SubParams>
  kj::Promise<void> tailCall(Request<SubParams, Results>&& tailRequest);
# 289 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
  void allowCancellation();
# 311 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
private:
  CallContextHook* hook;

  friend class Capability::Server;
  friend struct DynamicCapability;
};

class Capability::Server {




public:
  typedef Capability Serves;

  virtual kj::Promise<void> dispatchCall(uint64_t interfaceId, uint16_t methodId,
                                         CallContext<AnyPointer, AnyPointer> context) = 0;







protected:
  inline Capability::Client thisCap();
# 347 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
  template <typename Params, typename Results>
  CallContext<Params, Results> internalGetTypedContext(
      CallContext<AnyPointer, AnyPointer> typeless);
  kj::Promise<void> internalUnimplemented(const char* actualInterfaceName,
                                          uint64_t requestedTypeId);
  kj::Promise<void> internalUnimplemented(const char* interfaceName,
                                          uint64_t typeId, uint16_t methodId);
  kj::Promise<void> internalUnimplemented(const char* interfaceName, const char* methodName,
                                          uint64_t typeId, uint16_t methodId);

private:
  ClientHook* thisHook = nullptr;
  friend class LocalClient;
};



class ReaderCapabilityTable: private _::CapTableReader {
# 378 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
public:
  explicit ReaderCapabilityTable(kj::Array<kj::Maybe<kj::Own<ClientHook>>> table);
  ReaderCapabilityTable(const ReaderCapabilityTable&) = delete; ReaderCapabilityTable& operator=(const ReaderCapabilityTable&) = delete;

  template <typename T>
  T imbue(T reader);



private:
  kj::Array<kj::Maybe<kj::Own<ClientHook>>> table;

  kj::Maybe<kj::Own<ClientHook>> extractCap(uint index) override;
};

class BuilderCapabilityTable: private _::CapTableBuilder {





public:
  BuilderCapabilityTable();
  BuilderCapabilityTable(const BuilderCapabilityTable&) = delete; BuilderCapabilityTable& operator=(const BuilderCapabilityTable&) = delete;

  inline kj::ArrayPtr<kj::Maybe<kj::Own<ClientHook>>> getTable() { return table; }

  template <typename T>
  T imbue(T builder);



private:
  kj::Vector<kj::Maybe<kj::Own<ClientHook>>> table;

  kj::Maybe<kj::Own<ClientHook>> extractCap(uint index) override;
  uint injectCap(kj::Own<ClientHook>&& cap) override;
  void dropCap(uint index) override;
};



namespace _ {

class CapabilityServerSetBase {
public:
  Capability::Client addInternal(kj::Own<Capability::Server>&& server, void* ptr);
  kj::Promise<void*> getLocalServerInternal(Capability::Client& client);
};

}

template <typename T>
class CapabilityServerSet: private _::CapabilityServerSetBase {
# 444 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
public:
  CapabilityServerSet() = default;
  CapabilityServerSet(const CapabilityServerSet&) = delete; CapabilityServerSet& operator=(const CapabilityServerSet&) = delete;

  typename T::Client add(kj::Own<typename T::Server>&& server);


  kj::Promise<kj::Maybe<typename T::Server&>> getLocalServer(typename T::Client& client);





};





class RequestHook {


public:
  virtual RemotePromise<AnyPointer> send() = 0;


  virtual const void* getBrand() = 0;




  template <typename T, typename U>
  inline static kj::Own<RequestHook> from(Request<T, U>&& request) {
    return kj::mv(request.hook);
  }
};

class ResponseHook {





public:
  virtual ~ResponseHook() noexcept(false);


  template <typename T>
  inline static kj::Own<ResponseHook> from(Response<T>&& response) {
    return kj::mv(response.hook);
  }
};



class ClientHook {
public:
  ClientHook();

  virtual Request<AnyPointer, AnyPointer> newCall(
      uint64_t interfaceId, uint16_t methodId, kj::Maybe<MessageSize> sizeHint) = 0;



  struct VoidPromiseAndPipeline {
    kj::Promise<void> promise;
    kj::Own<PipelineHook> pipeline;
  };

  virtual VoidPromiseAndPipeline call(uint64_t interfaceId, uint16_t methodId,
                                      kj::Own<CallContextHook>&& context) = 0;
# 529 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../capnp/capability.h" 3
  virtual kj::Maybe<ClientHook&> getResolved() = 0;





  virtual kj::Maybe<kj::Promise<kj::Own<ClientHook>>> whenMoreResolved() = 0;





  kj::Promise<void> whenResolved();


  virtual kj::Own<ClientHook> addRef() = 0;


  virtual const void* getBrand() = 0;




  static const uint NULL_CAPABILITY_BRAND;


  inline bool isNull() { return getBrand() == &NULL_CAPABILITY_BRAND; }



  virtual void* getLocalServer(_::CapabilityServerSetBase& capServerSet);




  static kj::Own<ClientHook> from(Capability::Client client) { return kj::mv(client.hook); }
};

class CallContextHook {



public:
  virtual AnyPointer::Reader getParams() = 0;
  virtual void releaseParams() = 0;
  virtual AnyPointer::Builder getResults(kj::Maybe<MessageSize> sizeHint) = 0;
  virtual kj::Promise<void> tailCall(kj::Own<RequestHook>&& request) = 0;
  virtual void allowCancellation() = 0;

  virtual kj::Promise<AnyPointer::Pipeline> onTailCall() = 0;



  virtual ClientHook::VoidPromiseAndPipeline directTailCall(kj::Own<RequestHook>&& request) = 0;




  virtual kj::Own<CallContextHook> addRef() = 0;
};

kj::Own<ClientHook> newLocalPromiseClient(kj::Promise<kj::Own<ClientHook>>&& promise);




kj::Own<PipelineHook> newLocalPromisePipeline(kj::Promise<kj::Own<PipelineHook>>&& promise);



kj::Own<ClientHook> newBrokenCap(kj::StringPtr reason);
kj::Own<ClientHook> newBrokenCap(kj::Exception&& reason);


kj::Own<PipelineHook> newBrokenPipeline(kj::Exception&& reason);


Request<AnyPointer, AnyPointer> newBrokenRequest(
    kj::Exception&& reason, kj::Maybe<MessageSize> sizeHint);





namespace _ {

template <typename T>
struct PointerHelpers<T, Kind::INTERFACE> {
  static inline typename T::Client get(PointerReader reader) {
    return typename T::Client(reader.getCapability());
  }
  static inline typename T::Client get(PointerBuilder builder) {
    return typename T::Client(builder.getCapability());
  }
  static inline void set(PointerBuilder builder, typename T::Client&& value) {
    builder.setCapability(kj::mv(value.Capability::Client::hook));
  }
  static inline void set(PointerBuilder builder, typename T::Client& value) {
    builder.setCapability(value.Capability::Client::hook->addRef());
  }
  static inline void adopt(PointerBuilder builder, Orphan<T>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<T> disown(PointerBuilder builder) {
    return Orphan<T>(builder.disown());
  }
};

}




template <typename T>
struct List<T, Kind::INTERFACE> {
  List() = delete;

  class Reader {
  public:
    typedef List<T> Reads;

    Reader() = default;
    inline explicit Reader(_::ListReader reader): reader(reader) {}

    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
    inline typename T::Client operator[](uint index) const {
                                 ;
      return typename T::Client(reader.getPointerElement(
          bounded(index) * ELEMENTS).getCapability());
    }

    typedef _::IndexingIterator<const Reader, typename T::Client> Iterator;
    inline Iterator begin() const { return Iterator(this, 0); }
    inline Iterator end() const { return Iterator(this, size()); }

  private:
    _::ListReader reader;
    template <typename U, Kind K>
    friend struct _::PointerHelpers;
    template <typename U, Kind K>
    friend struct List;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

  class Builder {
  public:
    typedef List<T> Builds;

    Builder() = delete;
    inline Builder(decltype(nullptr)) {}
    inline explicit Builder(_::ListBuilder builder): builder(builder) {}

    inline operator Reader() const { return Reader(builder.asReader()); }
    inline Reader asReader() const { return Reader(builder.asReader()); }

    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
    inline typename T::Client operator[](uint index) {
                                 ;
      return typename T::Client(builder.getPointerElement(
          bounded(index) * ELEMENTS).getCapability());
    }
    inline void set(uint index, typename T::Client value) {
                                 ;
      builder.getPointerElement(bounded(index) * ELEMENTS).setCapability(kj::mv(value.hook));
    }
    inline void adopt(uint index, Orphan<T>&& value) {
                                 ;
      builder.getPointerElement(bounded(index) * ELEMENTS).adopt(kj::mv(value));
    }
    inline Orphan<T> disown(uint index) {
                                 ;
      return Orphan<T>(builder.getPointerElement(bounded(index) * ELEMENTS).disown());
    }

    typedef _::IndexingIterator<Builder, typename T::Client> Iterator;
    inline Iterator begin() { return Iterator(this, 0); }
    inline Iterator end() { return Iterator(this, size()); }

  private:
    _::ListBuilder builder;
    friend class Orphanage;
    template <typename U, Kind K>
    friend struct ToDynamic_;
  };

private:
  inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
    return builder.initList(ElementSize::POINTER, bounded(size) * ELEMENTS);
  }
  inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
    return builder.getList(ElementSize::POINTER, defaultValue);
  }
  inline static _::ListReader getFromPointer(
      const _::PointerReader& reader, const word* defaultValue) {
    return reader.getList(ElementSize::POINTER, defaultValue);
  }

  template <typename U, Kind k>
  friend struct List;
  template <typename U, Kind K>
  friend struct _::PointerHelpers;
};




template <typename Params, typename Results>
RemotePromise<Results> Request<Params, Results>::send() {
  auto typelessPromise = hook->send();
  hook = nullptr;




  auto typedPromise = kj::implicitCast<kj::Promise<Response<AnyPointer>>&>(typelessPromise)
      .then([](Response<AnyPointer>&& response) -> Response<Results> {
        return Response<Results>(response.getAs<Results>(), kj::mv(response.hook));
      });


  typename Results::Pipeline typedPipeline(
      kj::mv(kj::implicitCast<AnyPointer::Pipeline&>(typelessPromise)));

  return RemotePromise<Results>(kj::mv(typedPromise), kj::mv(typedPipeline));
}

inline Capability::Client::Client(kj::Own<ClientHook>&& hook): hook(kj::mv(hook)) {}
template <typename T, typename>
inline Capability::Client::Client(kj::Own<T>&& server)
    : hook(makeLocalClient(kj::mv(server))) {}
template <typename T, typename>
inline Capability::Client::Client(kj::Promise<T>&& promise)
    : hook(newLocalPromiseClient(promise.then([](T&& t) { return kj::mv(t.hook); }))) {}
inline Capability::Client::Client(Client& other): hook(other.hook->addRef()) {}
inline Capability::Client& Capability::Client::operator=(Client& other) {
  hook = other.hook->addRef();
  return *this;
}
template <typename T>
inline typename T::Client Capability::Client::castAs() {
  return typename T::Client(hook->addRef());
}
inline kj::Promise<void> Capability::Client::whenResolved() {
  return hook->whenResolved();
}
inline Request<AnyPointer, AnyPointer> Capability::Client::typelessRequest(
    uint64_t interfaceId, uint16_t methodId,
    kj::Maybe<MessageSize> sizeHint) {
  return newCall<AnyPointer, AnyPointer>(interfaceId, methodId, sizeHint);
}
template <typename Params, typename Results>
inline Request<Params, Results> Capability::Client::newCall(
    uint64_t interfaceId, uint16_t methodId, kj::Maybe<MessageSize> sizeHint) {
  auto typeless = hook->newCall(interfaceId, methodId, sizeHint);
  return Request<Params, Results>(typeless.template getAs<Params>(), kj::mv(typeless.hook));
}

template <typename Params, typename Results>
inline CallContext<Params, Results>::CallContext(CallContextHook& hook): hook(&hook) {}
template <typename Params, typename Results>
inline typename Params::Reader CallContext<Params, Results>::getParams() {
  return hook->getParams().template getAs<Params>();
}
template <typename Params, typename Results>
inline void CallContext<Params, Results>::releaseParams() {
  hook->releaseParams();
}
template <typename Params, typename Results>
inline typename Results::Builder CallContext<Params, Results>::getResults(
    kj::Maybe<MessageSize> sizeHint) {

  return hook->getResults(sizeHint).template getAs<Results>();
}
template <typename Params, typename Results>
inline typename Results::Builder CallContext<Params, Results>::initResults(
    kj::Maybe<MessageSize> sizeHint) {

  return hook->getResults(sizeHint).template initAs<Results>();
}
template <typename Params, typename Results>
inline void CallContext<Params, Results>::setResults(typename Results::Reader value) {
  hook->getResults(value.totalSize()).template setAs<Results>(value);
}
template <typename Params, typename Results>
inline void CallContext<Params, Results>::adoptResults(Orphan<Results>&& value) {
  hook->getResults(nullptr).adopt(kj::mv(value));
}
template <typename Params, typename Results>
inline Orphanage CallContext<Params, Results>::getResultsOrphanage(
    kj::Maybe<MessageSize> sizeHint) {
  return Orphanage::getForMessageContaining(hook->getResults(sizeHint));
}
template <typename Params, typename Results>
template <typename SubParams>
inline kj::Promise<void> CallContext<Params, Results>::tailCall(
    Request<SubParams, Results>&& tailRequest) {
  return hook->tailCall(kj::mv(tailRequest.hook));
}
template <typename Params, typename Results>
inline void CallContext<Params, Results>::allowCancellation() {
  hook->allowCancellation();
}

template <typename Params, typename Results>
CallContext<Params, Results> Capability::Server::internalGetTypedContext(
    CallContext<AnyPointer, AnyPointer> typeless) {
  return CallContext<Params, Results>(*typeless.hook);
}

Capability::Client Capability::Server::thisCap() {
  return Client(thisHook->addRef());
}

template <typename T>
T ReaderCapabilityTable::imbue(T reader) {
  return T(_::PointerHelpers<FromReader<T>>::getInternalReader(reader).imbue(this));
}

template <typename T>
T BuilderCapabilityTable::imbue(T builder) {
  return T(_::PointerHelpers<FromBuilder<T>>::getInternalBuilder(kj::mv(builder)).imbue(this));
}

template <typename T>
typename T::Client CapabilityServerSet<T>::add(kj::Own<typename T::Server>&& server) {
  void* ptr = reinterpret_cast<void*>(server.get());


  return addInternal(kj::mv(server), ptr).template castAs<T>();
}

template <typename T>
kj::Promise<kj::Maybe<typename T::Server&>> CapabilityServerSet<T>::getLocalServer(
    typename T::Client& client) {
  return getLocalServerInternal(client)
      .then([](void* server) -> kj::Maybe<typename T::Server&> {
    if (server == nullptr) {
      return nullptr;
    } else {
      return *reinterpret_cast<typename T::Server*>(server);
    }
  });
}

template <typename T>
struct Orphanage::GetInnerReader<T, Kind::INTERFACE> {
  static inline kj::Own<ClientHook> apply(typename T::Client t) {
    return ClientHook::from(kj::mv(t));
  }
};

}
# 45 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h" 2 3

namespace capnp {

class MessageReader;
class MessageBuilder;

struct DynamicValue {
  DynamicValue() = delete;

  enum Type {
    UNKNOWN,




    VOID,
    BOOL,
    INT,
    UINT,
    FLOAT,
    TEXT,
    DATA,
    LIST,
    ENUM,
    STRUCT,
    CAPABILITY,
    ANY_POINTER
  };

  class Reader;
  class Builder;
  class Pipeline;
};
class DynamicEnum;
struct DynamicStruct {
  DynamicStruct() = delete;
  class Reader;
  class Builder;
  class Pipeline;
};
struct DynamicList {
  DynamicList() = delete;
  class Reader;
  class Builder;
};
struct DynamicCapability {
  DynamicCapability() = delete;
  class Client;
  class Server;
};
template <> class Orphan<DynamicValue>;

template <Kind k> struct DynamicTypeFor_;
template <> struct DynamicTypeFor_<Kind::ENUM> { typedef DynamicEnum Type; };
template <> struct DynamicTypeFor_<Kind::STRUCT> { typedef DynamicStruct Type; };
template <> struct DynamicTypeFor_<Kind::LIST> { typedef DynamicList Type; };
template <> struct DynamicTypeFor_<Kind::INTERFACE> { typedef DynamicCapability Type; };

template <typename T>
using DynamicTypeFor = typename DynamicTypeFor_<kind<T>()>::Type;

template <typename T>
ReaderFor<DynamicTypeFor<FromReader<T>>> toDynamic(T&& value);
template <typename T>
BuilderFor<DynamicTypeFor<FromBuilder<T>>> toDynamic(T&& value);
template <typename T>
DynamicTypeFor<TypeIfEnum<T>> toDynamic(T&& value);
template <typename T>
typename DynamicTypeFor<FromServer<T>>::Client toDynamic(kj::Own<T>&& value);

namespace _ {

template <> struct Kind_<DynamicValue > { static constexpr Kind kind = Kind::OTHER; };
template <> struct Kind_<DynamicEnum > { static constexpr Kind kind = Kind::OTHER; };
template <> struct Kind_<DynamicStruct > { static constexpr Kind kind = Kind::OTHER; };
template <> struct Kind_<DynamicList > { static constexpr Kind kind = Kind::OTHER; };
template <> struct Kind_<DynamicCapability> { static constexpr Kind kind = Kind::OTHER; };

}

template <> inline constexpr Style style<DynamicValue >() { return Style::POINTER; }
template <> inline constexpr Style style<DynamicEnum >() { return Style::PRIMITIVE; }
template <> inline constexpr Style style<DynamicStruct >() { return Style::STRUCT; }
template <> inline constexpr Style style<DynamicList >() { return Style::POINTER; }
template <> inline constexpr Style style<DynamicCapability>() { return Style::CAPABILITY; }



class DynamicEnum {
public:
  DynamicEnum() = default;
  inline DynamicEnum(EnumSchema::Enumerant enumerant)
      : schema(enumerant.getContainingEnum()), value(enumerant.getOrdinal()) {}
  inline DynamicEnum(EnumSchema schema, uint16_t value)
      : schema(schema), value(value) {}

  template <typename T, typename = kj::EnableIf<kind<T>() == Kind::ENUM>>
  inline DynamicEnum(T&& value): DynamicEnum(toDynamic(value)) {}

  template <typename T>
  inline T as() const { return static_cast<T>(asImpl(typeId<T>())); }


  inline EnumSchema getSchema() const { return schema; }

  kj::Maybe<EnumSchema::Enumerant> getEnumerant() const;




  inline uint16_t getRaw() const { return value; }


private:
  EnumSchema schema;
  uint16_t value;

  uint16_t asImpl(uint64_t requestedTypeId) const;

  friend struct DynamicStruct;
  friend struct DynamicList;
  friend struct DynamicValue;
  template <typename T>
  friend DynamicTypeFor<TypeIfEnum<T>> toDynamic(T&& value);
};



class DynamicStruct::Reader {
public:
  typedef DynamicStruct Reads;

  Reader() = default;

  template <typename T, typename = kj::EnableIf<kind<FromReader<T>>() == Kind::STRUCT>>
  inline Reader(T&& value): Reader(toDynamic(value)) {}

  inline MessageSize totalSize() const { return reader.totalSize().asPublic(); }

  template <typename T>
  typename T::Reader as() const;


  inline StructSchema getSchema() const { return schema; }

  DynamicValue::Reader get(StructSchema::Field field) const;


  bool has(StructSchema::Field field) const;






  kj::Maybe<StructSchema::Field> which() const;






  DynamicValue::Reader get(kj::StringPtr name) const;
  bool has(kj::StringPtr name) const;


private:
  StructSchema schema;
  _::StructReader reader;

  inline Reader(StructSchema schema, _::StructReader reader)
      : schema(schema), reader(reader) {}
  Reader(StructSchema schema, const _::OrphanBuilder& orphan);

  bool isSetInUnion(StructSchema::Field field) const;
  void verifySetInUnion(StructSchema::Field field) const;
  static DynamicValue::Reader getImpl(_::StructReader reader, StructSchema::Field field);

  template <typename T, Kind K>
  friend struct _::PointerHelpers;
  friend class DynamicStruct::Builder;
  friend struct DynamicList;
  friend class MessageReader;
  friend class MessageBuilder;
  template <typename T, ::capnp::Kind k>
  friend struct ::capnp::ToDynamic_;
  friend kj::StringTree _::structString(
      _::StructReader reader, const _::RawBrandedSchema& schema);
  friend class Orphanage;
  friend class Orphan<DynamicStruct>;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
};

class DynamicStruct::Builder {
public:
  typedef DynamicStruct Builds;

  Builder() = default;
  inline Builder(decltype(nullptr)) {}

  template <typename T, typename = kj::EnableIf<kind<FromBuilder<T>>() == Kind::STRUCT>>
  inline Builder(T&& value): Builder(toDynamic(value)) {}

  inline MessageSize totalSize() const { return asReader().totalSize(); }

  template <typename T>
  typename T::Builder as();


  inline StructSchema getSchema() const { return schema; }

  DynamicValue::Builder get(StructSchema::Field field);


  inline bool has(StructSchema::Field field) { return asReader().has(field); }






  kj::Maybe<StructSchema::Field> which();






  void set(StructSchema::Field field, const DynamicValue::Reader& value);


  DynamicValue::Builder init(StructSchema::Field field);
  DynamicValue::Builder init(StructSchema::Field field, uint size);


  void adopt(StructSchema::Field field, Orphan<DynamicValue>&& orphan);
  Orphan<DynamicValue> disown(StructSchema::Field field);



  void clear(StructSchema::Field field);



  DynamicValue::Builder get(kj::StringPtr name);
  bool has(kj::StringPtr name);
  void set(kj::StringPtr name, const DynamicValue::Reader& value);
  void set(kj::StringPtr name, std::initializer_list<DynamicValue::Reader> value);
  DynamicValue::Builder init(kj::StringPtr name);
  DynamicValue::Builder init(kj::StringPtr name, uint size);
  void adopt(kj::StringPtr name, Orphan<DynamicValue>&& orphan);
  Orphan<DynamicValue> disown(kj::StringPtr name);
  void clear(kj::StringPtr name);


  Reader asReader() const;

private:
  StructSchema schema;
  _::StructBuilder builder;

  inline Builder(StructSchema schema, _::StructBuilder builder)
      : schema(schema), builder(builder) {}
  Builder(StructSchema schema, _::OrphanBuilder& orphan);

  bool isSetInUnion(StructSchema::Field field);
  void verifySetInUnion(StructSchema::Field field);
  void setInUnion(StructSchema::Field field);

  template <typename T, Kind k>
  friend struct _::PointerHelpers;
  friend struct DynamicList;
  friend class MessageReader;
  friend class MessageBuilder;
  template <typename T, ::capnp::Kind k>
  friend struct ::capnp::ToDynamic_;
  friend class Orphanage;
  friend class Orphan<DynamicStruct>;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
};

class DynamicStruct::Pipeline {
public:
  typedef DynamicStruct Pipelines;

  inline Pipeline(decltype(nullptr)): typeless(nullptr) {}

  template <typename T>
  typename T::Pipeline releaseAs();


  inline StructSchema getSchema() { return schema; }

  DynamicValue::Pipeline get(StructSchema::Field field);


  DynamicValue::Pipeline get(kj::StringPtr name);


private:
  StructSchema schema;
  AnyPointer::Pipeline typeless;

  inline explicit Pipeline(StructSchema schema, AnyPointer::Pipeline&& typeless)
      : schema(schema), typeless(kj::mv(typeless)) {}

  friend class Request<DynamicStruct, DynamicStruct>;
};



class DynamicList::Reader {
public:
  typedef DynamicList Reads;

  inline Reader(): reader(ElementSize::VOID) {}

  template <typename T, typename = kj::EnableIf<kind<FromReader<T>>() == Kind::LIST>>
  inline Reader(T&& value): Reader(toDynamic(value)) {}

  template <typename T>
  typename T::Reader as() const;



  inline ListSchema getSchema() const { return schema; }

  inline uint size() const { return unbound(reader.size() / ELEMENTS); }
  DynamicValue::Reader operator[](uint index) const;

  typedef _::IndexingIterator<const Reader, DynamicValue::Reader> Iterator;
  inline Iterator begin() const { return Iterator(this, 0); }
  inline Iterator end() const { return Iterator(this, size()); }

private:
  ListSchema schema;
  _::ListReader reader;

  Reader(ListSchema schema, _::ListReader reader): schema(schema), reader(reader) {}
  Reader(ListSchema schema, const _::OrphanBuilder& orphan);

  template <typename T, Kind k>
  friend struct _::PointerHelpers;
  friend struct DynamicStruct;
  friend class DynamicList::Builder;
  template <typename T, ::capnp::Kind k>
  friend struct ::capnp::ToDynamic_;
  friend class Orphanage;
  friend class Orphan<DynamicList>;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
};

class DynamicList::Builder {
public:
  typedef DynamicList Builds;

  inline Builder(): builder(ElementSize::VOID) {}
  inline Builder(decltype(nullptr)): builder(ElementSize::VOID) {}

  template <typename T, typename = kj::EnableIf<kind<FromBuilder<T>>() == Kind::LIST>>
  inline Builder(T&& value): Builder(toDynamic(value)) {}

  template <typename T>
  typename T::Builder as();



  inline ListSchema getSchema() const { return schema; }

  inline uint size() const { return unbound(builder.size() / ELEMENTS); }
  DynamicValue::Builder operator[](uint index);
  void set(uint index, const DynamicValue::Reader& value);
  DynamicValue::Builder init(uint index, uint size);
  void adopt(uint index, Orphan<DynamicValue>&& orphan);
  Orphan<DynamicValue> disown(uint index);

  typedef _::IndexingIterator<Builder, DynamicStruct::Builder> Iterator;
  inline Iterator begin() { return Iterator(this, 0); }
  inline Iterator end() { return Iterator(this, size()); }

  void copyFrom(std::initializer_list<DynamicValue::Reader> value);

  Reader asReader() const;

private:
  ListSchema schema;
  _::ListBuilder builder;

  Builder(ListSchema schema, _::ListBuilder builder): schema(schema), builder(builder) {}
  Builder(ListSchema schema, _::OrphanBuilder& orphan);

  template <typename T, Kind k>
  friend struct _::PointerHelpers;
  friend struct DynamicStruct;
  template <typename T, ::capnp::Kind k>
  friend struct ::capnp::ToDynamic_;
  friend class Orphanage;
  template <typename T, Kind k>
  friend struct _::OrphanGetImpl;
  friend class Orphan<DynamicList>;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
};



class DynamicCapability::Client: public Capability::Client {
public:
  typedef DynamicCapability Calls;
  typedef DynamicCapability Reads;

  Client() = default;

  template <typename T, typename = kj::EnableIf<kind<FromClient<T>>() == Kind::INTERFACE>>
  inline Client(T&& client);

  template <typename T, typename = kj::EnableIf<kj::canConvert<T*, DynamicCapability::Server*>()>>
  inline Client(kj::Own<T>&& server);

  template <typename T, typename = kj::EnableIf<kind<T>() == Kind::INTERFACE>>
  typename T::Client as();
  template <typename T, typename = kj::EnableIf<kind<T>() == Kind::INTERFACE>>
  typename T::Client releaseAs();


  Client upcast(InterfaceSchema requestedSchema);


  inline InterfaceSchema getSchema() { return schema; }

  Request<DynamicStruct, DynamicStruct> newRequest(
      InterfaceSchema::Method method, kj::Maybe<MessageSize> sizeHint = nullptr);
  Request<DynamicStruct, DynamicStruct> newRequest(
      kj::StringPtr methodName, kj::Maybe<MessageSize> sizeHint = nullptr);

private:
  InterfaceSchema schema;

  Client(InterfaceSchema schema, kj::Own<ClientHook>&& hook)
      : Capability::Client(kj::mv(hook)), schema(schema) {}

  template <typename T>
  inline Client(InterfaceSchema schema, kj::Own<T>&& server);

  friend struct Capability;
  friend struct DynamicStruct;
  friend struct DynamicList;
  friend struct DynamicValue;
  friend class Orphan<DynamicCapability>;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
  template <typename T, Kind k>
  friend struct _::PointerHelpers;
};

class DynamicCapability::Server: public Capability::Server {
public:
  typedef DynamicCapability Serves;

  Server(InterfaceSchema schema): schema(schema) {}

  virtual kj::Promise<void> call(InterfaceSchema::Method method,
                                 CallContext<DynamicStruct, DynamicStruct> context) = 0;

  kj::Promise<void> dispatchCall(uint64_t interfaceId, uint16_t methodId,
                                 CallContext<AnyPointer, AnyPointer> context) override final;

  inline InterfaceSchema getSchema() const { return schema; }

private:
  InterfaceSchema schema;
};

template <>
class Request<DynamicStruct, DynamicStruct>: public DynamicStruct::Builder {


public:
  inline Request(DynamicStruct::Builder builder, kj::Own<RequestHook>&& hook,
                 StructSchema resultSchema)
      : DynamicStruct::Builder(builder), hook(kj::mv(hook)), resultSchema(resultSchema) {}

  RemotePromise<DynamicStruct> send();


private:
  kj::Own<RequestHook> hook;
  StructSchema resultSchema;

  friend class Capability::Client;
  friend struct DynamicCapability;
  template <typename, typename>
  friend class CallContext;
  friend class RequestHook;
};

template <>
class CallContext<DynamicStruct, DynamicStruct>: public kj::DisallowConstCopy {





public:
  explicit CallContext(CallContextHook& hook, StructSchema paramType, StructSchema resultType);

  DynamicStruct::Reader getParams();
  void releaseParams();
  DynamicStruct::Builder getResults(kj::Maybe<MessageSize> sizeHint = nullptr);
  DynamicStruct::Builder initResults(kj::Maybe<MessageSize> sizeHint = nullptr);
  void setResults(DynamicStruct::Reader value);
  void adoptResults(Orphan<DynamicStruct>&& value);
  Orphanage getResultsOrphanage(kj::Maybe<MessageSize> sizeHint = nullptr);
  template <typename SubParams>
  kj::Promise<void> tailCall(Request<SubParams, DynamicStruct>&& tailRequest);
  void allowCancellation();

private:
  CallContextHook* hook;
  StructSchema paramType;
  StructSchema resultType;

  friend class DynamicCapability::Server;
};






template <> struct ReaderFor_ <DynamicEnum, Kind::OTHER> { typedef DynamicEnum Type; };
template <> struct BuilderFor_<DynamicEnum, Kind::OTHER> { typedef DynamicEnum Type; };
template <> struct ReaderFor_ <DynamicStruct, Kind::OTHER> { typedef DynamicStruct::Reader Type; };
template <> struct BuilderFor_<DynamicStruct, Kind::OTHER> { typedef DynamicStruct::Builder Type; };
template <> struct ReaderFor_ <DynamicList, Kind::OTHER> { typedef DynamicList::Reader Type; };
template <> struct BuilderFor_<DynamicList, Kind::OTHER> { typedef DynamicList::Builder Type; };
template <> struct ReaderFor_ <DynamicCapability, Kind::OTHER> { typedef DynamicCapability::Client Type; };
template <> struct BuilderFor_<DynamicCapability, Kind::OTHER> { typedef DynamicCapability::Client Type; };
template <> struct PipelineFor_<DynamicCapability, Kind::OTHER> { typedef DynamicCapability::Client Type; };

class DynamicValue::Reader {
public:
  typedef DynamicValue Reads;

  inline Reader(decltype(nullptr) n = nullptr);
  inline Reader(Void value);
  inline Reader(bool value);
  inline Reader(char value);
  inline Reader(signed char value);
  inline Reader(short value);
  inline Reader(int value);
  inline Reader(long value);
  inline Reader(long long value);
  inline Reader(unsigned char value);
  inline Reader(unsigned short value);
  inline Reader(unsigned int value);
  inline Reader(unsigned long value);
  inline Reader(unsigned long long value);
  inline Reader(float value);
  inline Reader(double value);
  inline Reader(const char* value);
  inline Reader(const Text::Reader& value);
  inline Reader(const Data::Reader& value);
  inline Reader(const DynamicList::Reader& value);
  inline Reader(DynamicEnum value);
  inline Reader(const DynamicStruct::Reader& value);
  inline Reader(const AnyPointer::Reader& value);
  inline Reader(DynamicCapability::Client& value);
  inline Reader(DynamicCapability::Client&& value);
  template <typename T, typename = kj::EnableIf<kj::canConvert<T*, DynamicCapability::Server*>()>>
  inline Reader(kj::Own<T>&& value);
  Reader(ConstSchema constant);

  template <typename T, typename = decltype(toDynamic(kj::instance<T>()))>
  inline Reader(T&& value): Reader(toDynamic(kj::mv(value))) {}

  Reader(const Reader& other);
  Reader(Reader&& other) noexcept;
  ~Reader() noexcept(false);
  Reader& operator=(const Reader& other);
  Reader& operator=(Reader&& other);



  template <typename T>
  inline ReaderFor<T> as() const { return AsImpl<T>::apply(*this); }
# 659 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h" 3
  inline Type getType() const { return type; }


private:
  Type type;

  union {
    Void voidValue;
    bool boolValue;
    int64_t intValue;
    uint64_t uintValue;
    double floatValue;
    Text::Reader textValue;
    Data::Reader dataValue;
    DynamicList::Reader listValue;
    DynamicEnum enumValue;
    DynamicStruct::Reader structValue;
    AnyPointer::Reader anyPointerValue;

    mutable DynamicCapability::Client capabilityValue;




  };

  template <typename T, Kind kind = kind<T>()> struct AsImpl;



  friend class Orphanage;
};

class DynamicValue::Builder {
public:
  typedef DynamicValue Builds;

  inline Builder(decltype(nullptr) n = nullptr);
  inline Builder(Void value);
  inline Builder(bool value);
  inline Builder(char value);
  inline Builder(signed char value);
  inline Builder(short value);
  inline Builder(int value);
  inline Builder(long value);
  inline Builder(long long value);
  inline Builder(unsigned char value);
  inline Builder(unsigned short value);
  inline Builder(unsigned int value);
  inline Builder(unsigned long value);
  inline Builder(unsigned long long value);
  inline Builder(float value);
  inline Builder(double value);
  inline Builder(Text::Builder value);
  inline Builder(Data::Builder value);
  inline Builder(DynamicList::Builder value);
  inline Builder(DynamicEnum value);
  inline Builder(DynamicStruct::Builder value);
  inline Builder(AnyPointer::Builder value);
  inline Builder(DynamicCapability::Client& value);
  inline Builder(DynamicCapability::Client&& value);

  template <typename T, typename = decltype(toDynamic(kj::instance<T>()))>
  inline Builder(T value): Builder(toDynamic(value)) {}

  Builder(Builder& other);
  Builder(Builder&& other) noexcept;
  ~Builder() noexcept(false);
  Builder& operator=(Builder& other);
  Builder& operator=(Builder&& other);



  template <typename T>
  inline BuilderFor<T> as() { return AsImpl<T>::apply(*this); }


  inline Type getType() { return type; }


  Reader asReader() const;

private:
  Type type;

  union {
    Void voidValue;
    bool boolValue;
    int64_t intValue;
    uint64_t uintValue;
    double floatValue;
    Text::Builder textValue;
    Data::Builder dataValue;
    DynamicList::Builder listValue;
    DynamicEnum enumValue;
    DynamicStruct::Builder structValue;
    AnyPointer::Builder anyPointerValue;

    mutable DynamicCapability::Client capabilityValue;

  };

  template <typename T, Kind kind = kind<T>()> struct AsImpl;



  friend class Orphan<DynamicValue>;
};

class DynamicValue::Pipeline {
public:
  typedef DynamicValue Pipelines;

  inline Pipeline(decltype(nullptr) n = nullptr);
  inline Pipeline(DynamicStruct::Pipeline&& value);
  inline Pipeline(DynamicCapability::Client&& value);

  Pipeline(Pipeline&& other) noexcept;
  Pipeline& operator=(Pipeline&& other);
  ~Pipeline() noexcept(false);

  template <typename T>
  inline PipelineFor<T> releaseAs() { return AsImpl<T>::apply(*this); }

  inline Type getType() { return type; }


private:
  Type type;
  union {
    DynamicStruct::Pipeline structValue;
    DynamicCapability::Client capabilityValue;
  };

  template <typename T, Kind kind = kind<T>()> struct AsImpl;


};

kj::StringTree operator*(::kj::_::Stringifier, const DynamicValue::Reader& value);
kj::StringTree operator*(::kj::_::Stringifier, const DynamicValue::Builder& value);
kj::StringTree operator*(::kj::_::Stringifier, DynamicEnum value);
kj::StringTree operator*(::kj::_::Stringifier, const DynamicStruct::Reader& value);
kj::StringTree operator*(::kj::_::Stringifier, const DynamicStruct::Builder& value);
kj::StringTree operator*(::kj::_::Stringifier, const DynamicList::Reader& value);
kj::StringTree operator*(::kj::_::Stringifier, const DynamicList::Builder& value);




template <>
class Orphan<DynamicStruct> {
public:
  Orphan() = default;
  Orphan(const Orphan&) = delete; Orphan& operator=(const Orphan&) = delete;
  Orphan(Orphan&&) = default;
  Orphan& operator=(Orphan&&) = default;

  template <typename T, typename = kj::EnableIf<kind<T>() == Kind::STRUCT>>
  inline Orphan(Orphan<T>&& other): schema(Schema::from<T>()), builder(kj::mv(other.builder)) {}

  DynamicStruct::Builder get();
  DynamicStruct::Reader getReader() const;

  template <typename T>
  Orphan<T> releaseAs();




  inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }

private:
  StructSchema schema;
  _::OrphanBuilder builder;

  inline Orphan(StructSchema schema, _::OrphanBuilder&& builder)
      : schema(schema), builder(kj::mv(builder)) {}

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend struct DynamicList;
  friend class Orphanage;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
  friend class MessageBuilder;
};

template <>
class Orphan<DynamicList> {
public:
  Orphan() = default;
  Orphan(const Orphan&) = delete; Orphan& operator=(const Orphan&) = delete;
  Orphan(Orphan&&) = default;
  Orphan& operator=(Orphan&&) = default;

  template <typename T, typename = kj::EnableIf<kind<T>() == Kind::LIST>>
  inline Orphan(Orphan<T>&& other): schema(Schema::from<T>()), builder(kj::mv(other.builder)) {}

  DynamicList::Builder get();
  DynamicList::Reader getReader() const;

  template <typename T>
  Orphan<T> releaseAs();






  inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }

private:
  ListSchema schema;
  _::OrphanBuilder builder;

  inline Orphan(ListSchema schema, _::OrphanBuilder&& builder)
      : schema(schema), builder(kj::mv(builder)) {}

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend struct DynamicList;
  friend class Orphanage;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
};

template <>
class Orphan<DynamicCapability> {
public:
  Orphan() = default;
  Orphan(const Orphan&) = delete; Orphan& operator=(const Orphan&) = delete;
  Orphan(Orphan&&) = default;
  Orphan& operator=(Orphan&&) = default;

  template <typename T, typename = kj::EnableIf<kind<T>() == Kind::INTERFACE>>
  inline Orphan(Orphan<T>&& other): schema(Schema::from<T>()), builder(kj::mv(other.builder)) {}

  DynamicCapability::Client get();
  DynamicCapability::Client getReader() const;

  template <typename T>
  Orphan<T> releaseAs();




  inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
  inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }

private:
  InterfaceSchema schema;
  _::OrphanBuilder builder;

  inline Orphan(InterfaceSchema schema, _::OrphanBuilder&& builder)
      : schema(schema), builder(kj::mv(builder)) {}

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend struct DynamicList;
  friend class Orphanage;
  friend class Orphan<DynamicValue>;
  friend class Orphan<AnyPointer>;
};

template <>
class Orphan<DynamicValue> {
public:
  inline Orphan(decltype(nullptr) n = nullptr): type(DynamicValue::UNKNOWN) {}
  inline Orphan(Void value);
  inline Orphan(bool value);
  inline Orphan(char value);
  inline Orphan(signed char value);
  inline Orphan(short value);
  inline Orphan(int value);
  inline Orphan(long value);
  inline Orphan(long long value);
  inline Orphan(unsigned char value);
  inline Orphan(unsigned short value);
  inline Orphan(unsigned int value);
  inline Orphan(unsigned long value);
  inline Orphan(unsigned long long value);
  inline Orphan(float value);
  inline Orphan(double value);
  inline Orphan(DynamicEnum value);
  Orphan(Orphan&&) = default;
  template <typename T>
  Orphan(Orphan<T>&&);
  Orphan(Orphan<AnyPointer>&&);
  Orphan(void*) = delete;
  Orphan(const Orphan&) = delete; Orphan& operator=(const Orphan&) = delete;

  Orphan& operator=(Orphan&&) = default;

  inline DynamicValue::Type getType() { return type; }

  DynamicValue::Builder get();
  DynamicValue::Reader getReader() const;

  template <typename T>
  Orphan<T> releaseAs();




private:
  DynamicValue::Type type;
  union {
    Void voidValue;
    bool boolValue;
    int64_t intValue;
    uint64_t uintValue;
    double floatValue;
    DynamicEnum enumValue;
    StructSchema structSchema;
    ListSchema listSchema;
    InterfaceSchema interfaceSchema;
  };

  _::OrphanBuilder builder;


  Orphan(DynamicValue::Builder value, _::OrphanBuilder&& builder);
  Orphan(DynamicValue::Type type, _::OrphanBuilder&& builder)
      : type(type), builder(kj::mv(builder)) {}
  Orphan(StructSchema structSchema, _::OrphanBuilder&& builder)
      : type(DynamicValue::STRUCT), structSchema(structSchema), builder(kj::mv(builder)) {}
  Orphan(ListSchema listSchema, _::OrphanBuilder&& builder)
      : type(DynamicValue::LIST), listSchema(listSchema), builder(kj::mv(builder)) {}

  template <typename, Kind>
  friend struct _::PointerHelpers;
  friend struct DynamicStruct;
  friend struct DynamicList;
  friend struct AnyPointer;
  friend class Orphanage;
};

template <typename T>
inline Orphan<DynamicValue>::Orphan(Orphan<T>&& other)
    : Orphan(other.get(), kj::mv(other.builder)) {}

inline Orphan<DynamicValue>::Orphan(Orphan<AnyPointer>&& other)
    : type(DynamicValue::ANY_POINTER), builder(kj::mv(other.builder)) {}

template <typename T>
Orphan<T> Orphan<DynamicStruct>::releaseAs() {
  get().as<T>();
  return Orphan<T>(kj::mv(builder));
}

template <typename T>
Orphan<T> Orphan<DynamicList>::releaseAs() {
  get().as<T>();
  return Orphan<T>(kj::mv(builder));
}

template <typename T>
Orphan<T> Orphan<DynamicCapability>::releaseAs() {
  get().as<T>();
  return Orphan<T>(kj::mv(builder));
}

template <typename T>
Orphan<T> Orphan<DynamicValue>::releaseAs() {
  get().as<T>();
  type = DynamicValue::UNKNOWN;
  return Orphan<T>(kj::mv(builder));
}

template <>
Orphan<AnyPointer> Orphan<DynamicValue>::releaseAs<AnyPointer>();
template <>
Orphan<DynamicStruct> Orphan<DynamicValue>::releaseAs<DynamicStruct>();
template <>
Orphan<DynamicList> Orphan<DynamicValue>::releaseAs<DynamicList>();
template <>
Orphan<DynamicCapability> Orphan<DynamicValue>::releaseAs<DynamicCapability>();

template <>
struct Orphanage::GetInnerBuilder<DynamicStruct, Kind::OTHER> {
  static inline _::StructBuilder apply(DynamicStruct::Builder& t) {
    return t.builder;
  }
};

template <>
struct Orphanage::GetInnerBuilder<DynamicList, Kind::OTHER> {
  static inline _::ListBuilder apply(DynamicList::Builder& t) {
    return t.builder;
  }
};

template <>
inline Orphan<DynamicStruct> Orphanage::newOrphanCopy<DynamicStruct::Reader>(
    DynamicStruct::Reader copyFrom) const {
  return Orphan<DynamicStruct>(
      copyFrom.getSchema(), _::OrphanBuilder::copy(arena, capTable, copyFrom.reader));
}

template <>
inline Orphan<DynamicList> Orphanage::newOrphanCopy<DynamicList::Reader>(
    DynamicList::Reader copyFrom) const {
  return Orphan<DynamicList>(copyFrom.getSchema(),
      _::OrphanBuilder::copy(arena, capTable, copyFrom.reader));
}

template <>
inline Orphan<DynamicCapability> Orphanage::newOrphanCopy<DynamicCapability::Client>(
    DynamicCapability::Client copyFrom) const {
  return Orphan<DynamicCapability>(
      copyFrom.getSchema(), _::OrphanBuilder::copy(arena, capTable, copyFrom.hook->addRef()));
}

template <>
Orphan<DynamicValue> Orphanage::newOrphanCopy<DynamicValue::Reader>(
    DynamicValue::Reader copyFrom) const;

namespace _ {

template <>
struct PointerHelpers<DynamicStruct, Kind::OTHER> {



  static DynamicStruct::Reader getDynamic(PointerReader reader, StructSchema schema);
  static DynamicStruct::Builder getDynamic(PointerBuilder builder, StructSchema schema);
  static void set(PointerBuilder builder, const DynamicStruct::Reader& value);
  static DynamicStruct::Builder init(PointerBuilder builder, StructSchema schema);
  static inline void adopt(PointerBuilder builder, Orphan<DynamicStruct>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<DynamicStruct> disown(PointerBuilder builder, StructSchema schema) {
    return Orphan<DynamicStruct>(schema, builder.disown());
  }
};

template <>
struct PointerHelpers<DynamicList, Kind::OTHER> {



  static DynamicList::Reader getDynamic(PointerReader reader, ListSchema schema);
  static DynamicList::Builder getDynamic(PointerBuilder builder, ListSchema schema);
  static void set(PointerBuilder builder, const DynamicList::Reader& value);
  static DynamicList::Builder init(PointerBuilder builder, ListSchema schema, uint size);
  static inline void adopt(PointerBuilder builder, Orphan<DynamicList>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<DynamicList> disown(PointerBuilder builder, ListSchema schema) {
    return Orphan<DynamicList>(schema, builder.disown());
  }
};

template <>
struct PointerHelpers<DynamicCapability, Kind::OTHER> {



  static DynamicCapability::Client getDynamic(PointerReader reader, InterfaceSchema schema);
  static DynamicCapability::Client getDynamic(PointerBuilder builder, InterfaceSchema schema);
  static void set(PointerBuilder builder, DynamicCapability::Client& value);
  static void set(PointerBuilder builder, DynamicCapability::Client&& value);
  static inline void adopt(PointerBuilder builder, Orphan<DynamicCapability>&& value) {
    builder.adopt(kj::mv(value.builder));
  }
  static inline Orphan<DynamicCapability> disown(PointerBuilder builder, InterfaceSchema schema) {
    return Orphan<DynamicCapability>(schema, builder.disown());
  }
};

}

template <typename T>
inline ReaderFor<T> AnyPointer::Reader::getAs(StructSchema schema) const {
  return _::PointerHelpers<T>::getDynamic(reader, schema);
}
template <typename T>
inline ReaderFor<T> AnyPointer::Reader::getAs(ListSchema schema) const {
  return _::PointerHelpers<T>::getDynamic(reader, schema);
}
template <typename T>
inline ReaderFor<T> AnyPointer::Reader::getAs(InterfaceSchema schema) const {
  return _::PointerHelpers<T>::getDynamic(reader, schema);
}
template <typename T>
inline BuilderFor<T> AnyPointer::Builder::getAs(StructSchema schema) {
  return _::PointerHelpers<T>::getDynamic(builder, schema);
}
template <typename T>
inline BuilderFor<T> AnyPointer::Builder::getAs(ListSchema schema) {
  return _::PointerHelpers<T>::getDynamic(builder, schema);
}
template <typename T>
inline BuilderFor<T> AnyPointer::Builder::getAs(InterfaceSchema schema) {
  return _::PointerHelpers<T>::getDynamic(builder, schema);
}
template <typename T>
inline BuilderFor<T> AnyPointer::Builder::initAs(StructSchema schema) {
  return _::PointerHelpers<T>::init(builder, schema);
}
template <typename T>
inline BuilderFor<T> AnyPointer::Builder::initAs(ListSchema schema, uint elementCount) {
  return _::PointerHelpers<T>::init(builder, schema, elementCount);
}
template <>
inline void AnyPointer::Builder::setAs<DynamicStruct>(DynamicStruct::Reader value) {
  return _::PointerHelpers<DynamicStruct>::set(builder, value);
}
template <>
inline void AnyPointer::Builder::setAs<DynamicList>(DynamicList::Reader value) {
  return _::PointerHelpers<DynamicList>::set(builder, value);
}
template <>
inline void AnyPointer::Builder::setAs<DynamicCapability>(DynamicCapability::Client value) {
  return _::PointerHelpers<DynamicCapability>::set(builder, kj::mv(value));
}
template <>
void AnyPointer::Builder::adopt<DynamicValue>(Orphan<DynamicValue>&& orphan);
template <typename T>
inline Orphan<T> AnyPointer::Builder::disownAs(StructSchema schema) {
  return _::PointerHelpers<T>::disown(builder, schema);
}
template <typename T>
inline Orphan<T> AnyPointer::Builder::disownAs(ListSchema schema) {
  return _::PointerHelpers<T>::disown(builder, schema);
}
template <typename T>
inline Orphan<T> AnyPointer::Builder::disownAs(InterfaceSchema schema) {
  return _::PointerHelpers<T>::disown(builder, schema);
}



template <>
inline DynamicStruct::Builder Orphan<AnyPointer>::getAs<DynamicStruct>(StructSchema schema) {
  return DynamicStruct::Builder(schema, builder);
}
template <>
inline DynamicStruct::Reader Orphan<AnyPointer>::getAsReader<DynamicStruct>(
    StructSchema schema) const {
  return DynamicStruct::Reader(schema, builder);
}
template <>
inline Orphan<DynamicStruct> Orphan<AnyPointer>::releaseAs<DynamicStruct>(StructSchema schema) {
  return Orphan<DynamicStruct>(schema, kj::mv(builder));
}
template <>
inline DynamicList::Builder Orphan<AnyPointer>::getAs<DynamicList>(ListSchema schema) {
  return DynamicList::Builder(schema, builder);
}
template <>
inline DynamicList::Reader Orphan<AnyPointer>::getAsReader<DynamicList>(ListSchema schema) const {
  return DynamicList::Reader(schema, builder);
}
template <>
inline Orphan<DynamicList> Orphan<AnyPointer>::releaseAs<DynamicList>(ListSchema schema) {
  return Orphan<DynamicList>(schema, kj::mv(builder));
}
template <>
inline DynamicCapability::Client Orphan<AnyPointer>::getAs<DynamicCapability>(
    InterfaceSchema schema) {
  return DynamicCapability::Client(schema, builder.asCapability());
}
template <>
inline DynamicCapability::Client Orphan<AnyPointer>::getAsReader<DynamicCapability>(
    InterfaceSchema schema) const {
  return DynamicCapability::Client(schema, builder.asCapability());
}
template <>
inline Orphan<DynamicCapability> Orphan<AnyPointer>::releaseAs<DynamicCapability>(
    InterfaceSchema schema) {
  return Orphan<DynamicCapability>(schema, kj::mv(builder));
}




template <typename T>
struct ToDynamic_<T, Kind::STRUCT> {
  static inline DynamicStruct::Reader apply(const typename T::Reader& value) {
    return DynamicStruct::Reader(Schema::from<T>(), value._reader);
  }
  static inline DynamicStruct::Builder apply(typename T::Builder& value) {
    return DynamicStruct::Builder(Schema::from<T>(), value._builder);
  }
};

template <typename T>
struct ToDynamic_<T, Kind::LIST> {
  static inline DynamicList::Reader apply(const typename T::Reader& value) {
    return DynamicList::Reader(Schema::from<T>(), value.reader);
  }
  static inline DynamicList::Builder apply(typename T::Builder& value) {
    return DynamicList::Builder(Schema::from<T>(), value.builder);
  }
};

template <typename T>
struct ToDynamic_<T, Kind::INTERFACE> {
  static inline DynamicCapability::Client apply(typename T::Client value) {
    return DynamicCapability::Client(kj::mv(value));
  }
  static inline DynamicCapability::Client apply(typename T::Client&& value) {
    return DynamicCapability::Client(kj::mv(value));
  }
};

template <typename T>
ReaderFor<DynamicTypeFor<FromReader<T>>> toDynamic(T&& value) {
  return ToDynamic_<FromReader<T>>::apply(value);
}
template <typename T>
BuilderFor<DynamicTypeFor<FromBuilder<T>>> toDynamic(T&& value) {
  return ToDynamic_<FromBuilder<T>>::apply(value);
}
template <typename T>
DynamicTypeFor<TypeIfEnum<T>> toDynamic(T&& value) {
  return DynamicEnum(Schema::from<kj::Decay<T>>(), static_cast<uint16_t>(value));
}
template <typename T>
typename DynamicTypeFor<FromServer<T>>::Client toDynamic(kj::Own<T>&& value) {
  return typename FromServer<T>::Client(kj::mv(value));
}

inline DynamicValue::Reader::Reader(std::nullptr_t n): type(UNKNOWN) {}
inline DynamicValue::Builder::Builder(std::nullptr_t n): type(UNKNOWN) {}

#define CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(cppType,typeTag,fieldName) inline DynamicValue::Reader::Reader(cppType value) : type(typeTag), fieldName##Value(value) {} inline DynamicValue::Builder::Builder(cppType value) : type(typeTag), fieldName##Value(value) {} inline Orphan<DynamicValue>::Orphan(cppType value) : type(DynamicValue::typeTag), fieldName##Value(value) {}







inline DynamicValue::Reader::Reader(Void value) : type(VOID), voidValue(value) {} inline DynamicValue::Builder::Builder(Void value) : type(VOID), voidValue(value) {} inline Orphan<DynamicValue>::Orphan(Void value) : type(DynamicValue::VOID), voidValue(value) {};
inline DynamicValue::Reader::Reader(bool value) : type(BOOL), boolValue(value) {} inline DynamicValue::Builder::Builder(bool value) : type(BOOL), boolValue(value) {} inline Orphan<DynamicValue>::Orphan(bool value) : type(DynamicValue::BOOL), boolValue(value) {};
inline DynamicValue::Reader::Reader(char value) : type(INT), intValue(value) {} inline DynamicValue::Builder::Builder(char value) : type(INT), intValue(value) {} inline Orphan<DynamicValue>::Orphan(char value) : type(DynamicValue::INT), intValue(value) {};
inline DynamicValue::Reader::Reader(signed char value) : type(INT), intValue(value) {} inline DynamicValue::Builder::Builder(signed char value) : type(INT), intValue(value) {} inline Orphan<DynamicValue>::Orphan(signed char value) : type(DynamicValue::INT), intValue(value) {};
inline DynamicValue::Reader::Reader(short value) : type(INT), intValue(value) {} inline DynamicValue::Builder::Builder(short value) : type(INT), intValue(value) {} inline Orphan<DynamicValue>::Orphan(short value) : type(DynamicValue::INT), intValue(value) {};
inline DynamicValue::Reader::Reader(int value) : type(INT), intValue(value) {} inline DynamicValue::Builder::Builder(int value) : type(INT), intValue(value) {} inline Orphan<DynamicValue>::Orphan(int value) : type(DynamicValue::INT), intValue(value) {};
inline DynamicValue::Reader::Reader(long value) : type(INT), intValue(value) {} inline DynamicValue::Builder::Builder(long value) : type(INT), intValue(value) {} inline Orphan<DynamicValue>::Orphan(long value) : type(DynamicValue::INT), intValue(value) {};
inline DynamicValue::Reader::Reader(long long value) : type(INT), intValue(value) {} inline DynamicValue::Builder::Builder(long long value) : type(INT), intValue(value) {} inline Orphan<DynamicValue>::Orphan(long long value) : type(DynamicValue::INT), intValue(value) {};
inline DynamicValue::Reader::Reader(unsigned char value) : type(UINT), uintValue(value) {} inline DynamicValue::Builder::Builder(unsigned char value) : type(UINT), uintValue(value) {} inline Orphan<DynamicValue>::Orphan(unsigned char value) : type(DynamicValue::UINT), uintValue(value) {};
inline DynamicValue::Reader::Reader(unsigned short value) : type(UINT), uintValue(value) {} inline DynamicValue::Builder::Builder(unsigned short value) : type(UINT), uintValue(value) {} inline Orphan<DynamicValue>::Orphan(unsigned short value) : type(DynamicValue::UINT), uintValue(value) {};
inline DynamicValue::Reader::Reader(unsigned int value) : type(UINT), uintValue(value) {} inline DynamicValue::Builder::Builder(unsigned int value) : type(UINT), uintValue(value) {} inline Orphan<DynamicValue>::Orphan(unsigned int value) : type(DynamicValue::UINT), uintValue(value) {};
inline DynamicValue::Reader::Reader(unsigned long value) : type(UINT), uintValue(value) {} inline DynamicValue::Builder::Builder(unsigned long value) : type(UINT), uintValue(value) {} inline Orphan<DynamicValue>::Orphan(unsigned long value) : type(DynamicValue::UINT), uintValue(value) {};
inline DynamicValue::Reader::Reader(unsigned long long value) : type(UINT), uintValue(value) {} inline DynamicValue::Builder::Builder(unsigned long long value) : type(UINT), uintValue(value) {} inline Orphan<DynamicValue>::Orphan(unsigned long long value) : type(DynamicValue::UINT), uintValue(value) {};
inline DynamicValue::Reader::Reader(float value) : type(FLOAT), floatValue(value) {} inline DynamicValue::Builder::Builder(float value) : type(FLOAT), floatValue(value) {} inline Orphan<DynamicValue>::Orphan(float value) : type(DynamicValue::FLOAT), floatValue(value) {};
inline DynamicValue::Reader::Reader(double value) : type(FLOAT), floatValue(value) {} inline DynamicValue::Builder::Builder(double value) : type(FLOAT), floatValue(value) {} inline Orphan<DynamicValue>::Orphan(double value) : type(DynamicValue::FLOAT), floatValue(value) {};
inline DynamicValue::Reader::Reader(DynamicEnum value) : type(ENUM), enumValue(value) {} inline DynamicValue::Builder::Builder(DynamicEnum value) : type(ENUM), enumValue(value) {} inline Orphan<DynamicValue>::Orphan(DynamicEnum value) : type(DynamicValue::ENUM), enumValue(value) {};
#undef CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR

#define CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(cppType,typeTag,fieldName) inline DynamicValue::Reader::Reader(const cppType::Reader& value) : type(typeTag), fieldName##Value(value) {} inline DynamicValue::Builder::Builder(cppType::Builder value) : type(typeTag), fieldName##Value(value) {}





inline DynamicValue::Reader::Reader(const Text::Reader& value) : type(TEXT), textValue(value) {} inline DynamicValue::Builder::Builder(Text::Builder value) : type(TEXT), textValue(value) {};
inline DynamicValue::Reader::Reader(const Data::Reader& value) : type(DATA), dataValue(value) {} inline DynamicValue::Builder::Builder(Data::Builder value) : type(DATA), dataValue(value) {};
inline DynamicValue::Reader::Reader(const DynamicList::Reader& value) : type(LIST), listValue(value) {} inline DynamicValue::Builder::Builder(DynamicList::Builder value) : type(LIST), listValue(value) {};
inline DynamicValue::Reader::Reader(const DynamicStruct::Reader& value) : type(STRUCT), structValue(value) {} inline DynamicValue::Builder::Builder(DynamicStruct::Builder value) : type(STRUCT), structValue(value) {};
inline DynamicValue::Reader::Reader(const AnyPointer::Reader& value) : type(ANY_POINTER), anyPointerValue(value) {} inline DynamicValue::Builder::Builder(AnyPointer::Builder value) : type(ANY_POINTER), anyPointerValue(value) {};

#undef CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR

inline DynamicValue::Reader::Reader(DynamicCapability::Client& value)
    : type(CAPABILITY), capabilityValue(value) {}
inline DynamicValue::Reader::Reader(DynamicCapability::Client&& value)
    : type(CAPABILITY), capabilityValue(kj::mv(value)) {}
template <typename T, typename>
inline DynamicValue::Reader::Reader(kj::Own<T>&& value)
    : type(CAPABILITY), capabilityValue(kj::mv(value)) {}
inline DynamicValue::Builder::Builder(DynamicCapability::Client& value)
    : type(CAPABILITY), capabilityValue(value) {}
inline DynamicValue::Builder::Builder(DynamicCapability::Client&& value)
    : type(CAPABILITY), capabilityValue(kj::mv(value)) {}

inline DynamicValue::Reader::Reader(const char* value): Reader(Text::Reader(value)) {}

#define CAPNP_DECLARE_TYPE(discrim,typeName) template <> struct DynamicValue::Reader::AsImpl<typeName> { static ReaderFor<typeName> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<typeName> { static BuilderFor<typeName> apply(Builder& builder); };
# 1354 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/../dynamic.h" 3
template <> struct DynamicValue::Reader::AsImpl<bool> { static ReaderFor<bool> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<bool> { static BuilderFor<bool> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<int8_t> { static ReaderFor<int8_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<int8_t> { static BuilderFor<int8_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<int16_t> { static ReaderFor<int16_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<int16_t> { static BuilderFor<int16_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<int32_t> { static ReaderFor<int32_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<int32_t> { static BuilderFor<int32_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<int64_t> { static ReaderFor<int64_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<int64_t> { static BuilderFor<int64_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<uint8_t> { static ReaderFor<uint8_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<uint8_t> { static BuilderFor<uint8_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<uint16_t> { static ReaderFor<uint16_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<uint16_t> { static BuilderFor<uint16_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<uint32_t> { static ReaderFor<uint32_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<uint32_t> { static BuilderFor<uint32_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<uint64_t> { static ReaderFor<uint64_t> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<uint64_t> { static BuilderFor<uint64_t> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<float> { static ReaderFor<float> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<float> { static BuilderFor<float> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<double> { static ReaderFor<double> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<double> { static BuilderFor<double> apply(Builder& builder); };

template <> struct DynamicValue::Reader::AsImpl<Text> { static ReaderFor<Text> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<Text> { static BuilderFor<Text> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<Data> { static ReaderFor<Data> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<Data> { static BuilderFor<Data> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<DynamicList> { static ReaderFor<DynamicList> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<DynamicList> { static BuilderFor<DynamicList> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<DynamicStruct> { static ReaderFor<DynamicStruct> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<DynamicStruct> { static BuilderFor<DynamicStruct> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<DynamicCapability> { static ReaderFor<DynamicCapability> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<DynamicCapability> { static BuilderFor<DynamicCapability> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<DynamicEnum> { static ReaderFor<DynamicEnum> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<DynamicEnum> { static BuilderFor<DynamicEnum> apply(Builder& builder); };
template <> struct DynamicValue::Reader::AsImpl<AnyPointer> { static ReaderFor<AnyPointer> apply(const Reader& reader); }; template <> struct DynamicValue::Builder::AsImpl<AnyPointer> { static BuilderFor<AnyPointer> apply(Builder& builder); };
#undef CAPNP_DECLARE_TYPE



template <>
struct DynamicValue::Reader::AsImpl<Void> {
  static Void apply(const Reader& reader);
};
template <>
struct DynamicValue::Builder::AsImpl<Void> {
  static Void apply(Builder& builder);
};

template <typename T>
struct DynamicValue::Reader::AsImpl<T, Kind::ENUM> {
  static T apply(const Reader& reader) {
    return reader.as<DynamicEnum>().as<T>();
  }
};
template <typename T>
struct DynamicValue::Builder::AsImpl<T, Kind::ENUM> {
  static T apply(Builder& builder) {
    return builder.as<DynamicEnum>().as<T>();
  }
};

template <typename T>
struct DynamicValue::Reader::AsImpl<T, Kind::STRUCT> {
  static typename T::Reader apply(const Reader& reader) {
    return reader.as<DynamicStruct>().as<T>();
  }
};
template <typename T>
struct DynamicValue::Builder::AsImpl<T, Kind::STRUCT> {
  static typename T::Builder apply(Builder& builder) {
    return builder.as<DynamicStruct>().as<T>();
  }
};

template <typename T>
struct DynamicValue::Reader::AsImpl<T, Kind::LIST> {
  static typename T::Reader apply(const Reader& reader) {
    return reader.as<DynamicList>().as<T>();
  }
};
template <typename T>
struct DynamicValue::Builder::AsImpl<T, Kind::LIST> {
  static typename T::Builder apply(Builder& builder) {
    return builder.as<DynamicList>().as<T>();
  }
};

template <typename T>
struct DynamicValue::Reader::AsImpl<T, Kind::INTERFACE> {
  static typename T::Client apply(const Reader& reader) {
    return reader.as<DynamicCapability>().as<T>();
  }
};
template <typename T>
struct DynamicValue::Builder::AsImpl<T, Kind::INTERFACE> {
  static typename T::Client apply(Builder& builder) {
    return builder.as<DynamicCapability>().as<T>();
  }
};

template <>
struct DynamicValue::Reader::AsImpl<DynamicValue> {
  static DynamicValue::Reader apply(const Reader& reader) {
    return reader;
  }
};
template <>
struct DynamicValue::Builder::AsImpl<DynamicValue> {
  static DynamicValue::Builder apply(Builder& builder) {
    return builder;
  }
};

inline DynamicValue::Pipeline::Pipeline(std::nullptr_t n): type(UNKNOWN) {}
inline DynamicValue::Pipeline::Pipeline(DynamicStruct::Pipeline&& value)
    : type(STRUCT), structValue(kj::mv(value)) {}
inline DynamicValue::Pipeline::Pipeline(DynamicCapability::Client&& value)
    : type(CAPABILITY), capabilityValue(kj::mv(value)) {}

template <typename T>
struct DynamicValue::Pipeline::AsImpl<T, Kind::STRUCT> {
  static typename T::Pipeline apply(Pipeline& pipeline) {
    return pipeline.releaseAs<DynamicStruct>().releaseAs<T>();
  }
};
template <typename T>
struct DynamicValue::Pipeline::AsImpl<T, Kind::INTERFACE> {
  static typename T::Client apply(Pipeline& pipeline) {
    return pipeline.releaseAs<DynamicCapability>().releaseAs<T>();
  }
};
template <>
struct DynamicValue::Pipeline::AsImpl<DynamicStruct, Kind::OTHER> {
  static PipelineFor<DynamicStruct> apply(Pipeline& pipeline);
};
template <>
struct DynamicValue::Pipeline::AsImpl<DynamicCapability, Kind::OTHER> {
  static PipelineFor<DynamicCapability> apply(Pipeline& pipeline);
};



template <typename T>
typename T::Reader DynamicStruct::Reader::as() const {
  static_assert(kind<T>() == Kind::STRUCT,
                "DynamicStruct::Reader::as<T>() can only convert to struct types.");
  schema.requireUsableAs<T>();
  return typename T::Reader(reader);
}

template <typename T>
typename T::Builder DynamicStruct::Builder::as() {
  static_assert(kind<T>() == Kind::STRUCT,
                "DynamicStruct::Builder::as<T>() can only convert to struct types.");
  schema.requireUsableAs<T>();
  return typename T::Builder(builder);
}

template <>
inline DynamicStruct::Reader DynamicStruct::Reader::as<DynamicStruct>() const {
  return *this;
}
template <>
inline DynamicStruct::Builder DynamicStruct::Builder::as<DynamicStruct>() {
  return *this;
}

inline DynamicStruct::Reader DynamicStruct::Builder::asReader() const {
  return DynamicStruct::Reader(schema, builder.asReader());
}

template <>
inline AnyStruct::Reader DynamicStruct::Reader::as<AnyStruct>() const {
  return AnyStruct::Reader(reader);
}

template <>
inline AnyStruct::Builder DynamicStruct::Builder::as<AnyStruct>() {
  return AnyStruct::Builder(builder);
}

template <typename T>
typename T::Pipeline DynamicStruct::Pipeline::releaseAs() {
  static_assert(kind<T>() == Kind::STRUCT,
                "DynamicStruct::Pipeline::releaseAs<T>() can only convert to struct types.");
  schema.requireUsableAs<T>();
  return typename T::Pipeline(kj::mv(typeless));
}



template <typename T>
typename T::Reader DynamicList::Reader::as() const {
  static_assert(kind<T>() == Kind::LIST,
                "DynamicStruct::Reader::as<T>() can only convert to list types.");
  schema.requireUsableAs<T>();
  return typename T::Reader(reader);
}
template <typename T>
typename T::Builder DynamicList::Builder::as() {
  static_assert(kind<T>() == Kind::LIST,
                "DynamicStruct::Builder::as<T>() can only convert to list types.");
  schema.requireUsableAs<T>();
  return typename T::Builder(builder);
}

template <>
inline DynamicList::Reader DynamicList::Reader::as<DynamicList>() const {
  return *this;
}
template <>
inline DynamicList::Builder DynamicList::Builder::as<DynamicList>() {
  return *this;
}

template <>
inline AnyList::Reader DynamicList::Reader::as<AnyList>() const {
  return AnyList::Reader(reader);
}

template <>
inline AnyList::Builder DynamicList::Builder::as<AnyList>() {
  return AnyList::Builder(builder);
}



template <typename T, typename>
inline DynamicCapability::Client::Client(T&& client)
    : Capability::Client(kj::mv(client)), schema(Schema::from<FromClient<T>>()) {}

template <typename T, typename>
inline DynamicCapability::Client::Client(kj::Own<T>&& server)
    : Client(server->getSchema(), kj::mv(server)) {}
template <typename T>
inline DynamicCapability::Client::Client(InterfaceSchema schema, kj::Own<T>&& server)
    : Capability::Client(kj::mv(server)), schema(schema) {}

template <typename T, typename>
typename T::Client DynamicCapability::Client::as() {
  static_assert(kind<T>() == Kind::INTERFACE,
                "DynamicCapability::Client::as<T>() can only convert to interface types.");
  schema.requireUsableAs<T>();
  return typename T::Client(hook->addRef());
}

template <typename T, typename>
typename T::Client DynamicCapability::Client::releaseAs() {
  static_assert(kind<T>() == Kind::INTERFACE,
                "DynamicCapability::Client::as<T>() can only convert to interface types.");
  schema.requireUsableAs<T>();
  return typename T::Client(kj::mv(hook));
}

inline CallContext<DynamicStruct, DynamicStruct>::CallContext(
    CallContextHook& hook, StructSchema paramType, StructSchema resultType)
    : hook(&hook), paramType(paramType), resultType(resultType) {}
inline DynamicStruct::Reader CallContext<DynamicStruct, DynamicStruct>::getParams() {
  return hook->getParams().getAs<DynamicStruct>(paramType);
}
inline void CallContext<DynamicStruct, DynamicStruct>::releaseParams() {
  hook->releaseParams();
}
inline DynamicStruct::Builder CallContext<DynamicStruct, DynamicStruct>::getResults(
    kj::Maybe<MessageSize> sizeHint) {
  return hook->getResults(sizeHint).getAs<DynamicStruct>(resultType);
}
inline DynamicStruct::Builder CallContext<DynamicStruct, DynamicStruct>::initResults(
    kj::Maybe<MessageSize> sizeHint) {
  return hook->getResults(sizeHint).initAs<DynamicStruct>(resultType);
}
inline void CallContext<DynamicStruct, DynamicStruct>::setResults(DynamicStruct::Reader value) {
  hook->getResults(value.totalSize()).setAs<DynamicStruct>(value);
}
inline void CallContext<DynamicStruct, DynamicStruct>::adoptResults(Orphan<DynamicStruct>&& value) {
  hook->getResults(MessageSize { 0, 0 }).adopt(kj::mv(value));
}
inline Orphanage CallContext<DynamicStruct, DynamicStruct>::getResultsOrphanage(
    kj::Maybe<MessageSize> sizeHint) {
  return Orphanage::getForMessageContaining(hook->getResults(sizeHint));
}
template <typename SubParams>
inline kj::Promise<void> CallContext<DynamicStruct, DynamicStruct>::tailCall(
    Request<SubParams, DynamicStruct>&& tailRequest) {
  return hook->tailCall(kj::mv(tailRequest.hook));
}
inline void CallContext<DynamicStruct, DynamicStruct>::allowCancellation() {
  hook->allowCancellation();
}

template <>
inline DynamicCapability::Client Capability::Client::castAs<DynamicCapability>(
    InterfaceSchema schema) {
  return DynamicCapability::Client(schema, hook->addRef());
}



template <typename T>
ReaderFor<T> ConstSchema::as() const {
  return DynamicValue::Reader(*this).as<T>();
}

}
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 1
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h"
#define KJ_MINIPOSIX_H_ 
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 3







# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/limits.h" 1 3
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/limits.h" 3
#define __CLANG_LIMITS_H 




#define _GCC_LIMITS_H_ 






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/limits.h" 1 3 4

#define _LIMITS_H 






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/limits.h" 1 3 4


#define LONG_BIT 64


#define LONG_MAX 0x7fffffffffffffffL
#define LLONG_MAX 0x7fffffffffffffffLL
# 9 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/limits.h" 2 3 4




#define CHAR_MIN 0
#define CHAR_MAX 255







#define CHAR_BIT 8
#define SCHAR_MIN (-128)
#define SCHAR_MAX 127
#define UCHAR_MAX 255
#define SHRT_MIN (-1-0x7fff)
#define SHRT_MAX 0x7fff
#define USHRT_MAX 0xffff
#define INT_MIN (-1-0x7fffffff)
#define INT_MAX 0x7fffffff
#define UINT_MAX 0xffffffffU
#define LONG_MIN (-LONG_MAX-1)
#define ULONG_MAX (2UL*LONG_MAX+1)
#define LLONG_MIN (-LLONG_MAX-1)
#define ULLONG_MAX (2ULL*LLONG_MAX+1)

#define MB_LEN_MAX 4




#define PIPE_BUF 4096



#define FILESIZEBITS 64
#define NAME_MAX 255
#define SYMLINK_MAX 255
#define PATH_MAX 4096
#define NZERO 20
#define NGROUPS_MAX 32
#define ARG_MAX 131072
#define IOV_MAX 1024
#define SYMLOOP_MAX 40
#define WORD_BIT 32
#define SSIZE_MAX LONG_MAX
#define TZNAME_MAX 6
#define TTY_NAME_MAX 32
#define HOST_NAME_MAX 255



#define PTHREAD_KEYS_MAX 128
#define PTHREAD_STACK_MIN 2048
#define PTHREAD_DESTRUCTOR_ITERATIONS 4
#define SEM_VALUE_MAX 0x7fffffff
#define SEM_NSEMS_MAX 256
#define DELAYTIMER_MAX 0x7fffffff
#define MQ_PRIO_MAX 32768
#define LOGIN_NAME_MAX 256



#define BC_BASE_MAX 99
#define BC_DIM_MAX 2048
#define BC_SCALE_MAX 99
#define BC_STRING_MAX 1000
#define CHARCLASS_NAME_MAX 14
#define COLL_WEIGHTS_MAX 2
#define EXPR_NEST_MAX 32
#define LINE_MAX 4096
#define RE_DUP_MAX 255

#define NL_ARGMAX 9
#define NL_LANGMAX 32
#define NL_MSGMAX 32767
#define NL_SETMAX 255
#define NL_TEXTMAX 2048






#define NL_NMAX 16






#define _POSIX_AIO_LISTIO_MAX 2
#define _POSIX_AIO_MAX 1
#define _POSIX_ARG_MAX 4096
#define _POSIX_CHILD_MAX 25
#define _POSIX_CLOCKRES_MIN 20000000
#define _POSIX_DELAYTIMER_MAX 32
#define _POSIX_HOST_NAME_MAX 255
#define _POSIX_LINK_MAX 8
#define _POSIX_LOGIN_NAME_MAX 9
#define _POSIX_MAX_CANON 255
#define _POSIX_MAX_INPUT 255
#define _POSIX_MQ_OPEN_MAX 8
#define _POSIX_MQ_PRIO_MAX 32
#define _POSIX_NAME_MAX 14
#define _POSIX_NGROUPS_MAX 8
#define _POSIX_OPEN_MAX 20
#define _POSIX_PATH_MAX 256
#define _POSIX_PIPE_BUF 512
#define _POSIX_RE_DUP_MAX 255
#define _POSIX_RTSIG_MAX 8
#define _POSIX_SEM_NSEMS_MAX 256
#define _POSIX_SEM_VALUE_MAX 32767
#define _POSIX_SIGQUEUE_MAX 32
#define _POSIX_SSIZE_MAX 32767
#define _POSIX_STREAM_MAX 8
#define _POSIX_SS_REPL_MAX 4
#define _POSIX_SYMLINK_MAX 255
#define _POSIX_SYMLOOP_MAX 8
#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
#define _POSIX_THREAD_KEYS_MAX 128
#define _POSIX_THREAD_THREADS_MAX 64
#define _POSIX_TIMER_MAX 32
#define _POSIX_TRACE_EVENT_NAME_MAX 30
#define _POSIX_TRACE_NAME_MAX 8
#define _POSIX_TRACE_SYS_MAX 8
#define _POSIX_TRACE_USER_EVENT_MAX 32
#define _POSIX_TTY_NAME_MAX 9
#define _POSIX_TZNAME_MAX 6
#define _POSIX2_BC_BASE_MAX 99
#define _POSIX2_BC_DIM_MAX 2048
#define _POSIX2_BC_SCALE_MAX 99
#define _POSIX2_BC_STRING_MAX 1000
#define _POSIX2_CHARCLASS_NAME_MAX 14
#define _POSIX2_COLL_WEIGHTS_MAX 2
#define _POSIX2_EXPR_NEST_MAX 32
#define _POSIX2_LINE_MAX 2048
#define _POSIX2_RE_DUP_MAX 255

#define _XOPEN_IOV_MAX 16
#define _XOPEN_NAME_MAX 255
#define _XOPEN_PATH_MAX 1024
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/limits.h" 2 3




#undef SCHAR_MIN
#undef SCHAR_MAX
#undef UCHAR_MAX
#undef SHRT_MIN
#undef SHRT_MAX
#undef USHRT_MAX
#undef INT_MIN
#undef INT_MAX
#undef UINT_MAX
#undef LONG_MIN
#undef LONG_MAX
#undef ULONG_MAX

#undef CHAR_BIT
#undef CHAR_MIN
#undef CHAR_MAX


#define SCHAR_MAX __SCHAR_MAX__
#define SHRT_MAX __SHRT_MAX__
#define INT_MAX __INT_MAX__
#define LONG_MAX __LONG_MAX__

#define SCHAR_MIN (-__SCHAR_MAX__-1)
#define SHRT_MIN (-__SHRT_MAX__ -1)
#define INT_MIN (-__INT_MAX__ -1)
#define LONG_MIN (-__LONG_MAX__ -1L)

#define UCHAR_MAX (__SCHAR_MAX__*2 +1)
#define USHRT_MAX (__SHRT_MAX__ *2 +1)
#define UINT_MAX (__INT_MAX__ *2U +1U)
#define ULONG_MAX (__LONG_MAX__ *2UL+1UL)





#define CHAR_BIT __CHAR_BIT__


#define CHAR_MIN 0
#define CHAR_MAX UCHAR_MAX
# 94 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/limits.h" 3
#undef LLONG_MIN
#undef LLONG_MAX
#undef ULLONG_MAX

#define LLONG_MAX __LONG_LONG_MAX__
#define LLONG_MIN (-__LONG_LONG_MAX__-1LL)
#define ULLONG_MAX (__LONG_LONG_MAX__*2ULL+1ULL)
# 109 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/limits.h" 3
#undef LONG_LONG_MIN
#undef LONG_LONG_MAX
#undef ULONG_LONG_MAX

#define LONG_LONG_MAX __LONG_LONG_MAX__
#define LONG_LONG_MIN (-__LONG_LONG_MAX__-1LL)
#define ULONG_LONG_MAX (__LONG_LONG_MAX__*2ULL+1ULL)
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/errno.h" 1 3 4

#define _ERRNO_H 


extern "C" {





# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/errno.h" 1 3 4
#define EPERM 1
#define ENOENT 2
#define ESRCH 3
#define EINTR 4
#define EIO 5
#define ENXIO 6
#define E2BIG 7
#define ENOEXEC 8
#define EBADF 9
#define ECHILD 10
#define EAGAIN 11
#define ENOMEM 12
#define EACCES 13
#define EFAULT 14
#define ENOTBLK 15
#define EBUSY 16
#define EEXIST 17
#define EXDEV 18
#define ENODEV 19
#define ENOTDIR 20
#define EISDIR 21
#define EINVAL 22
#define ENFILE 23
#define EMFILE 24
#define ENOTTY 25
#define ETXTBSY 26
#define EFBIG 27
#define ENOSPC 28
#define ESPIPE 29
#define EROFS 30
#define EMLINK 31
#define EPIPE 32
#define EDOM 33
#define ERANGE 34
#define EDEADLK 35
#define ENAMETOOLONG 36
#define ENOLCK 37
#define ENOSYS 38
#define ENOTEMPTY 39
#define ELOOP 40
#define EWOULDBLOCK EAGAIN
#define ENOMSG 42
#define EIDRM 43
#define ECHRNG 44
#define EL2NSYNC 45
#define EL3HLT 46
#define EL3RST 47
#define ELNRNG 48
#define EUNATCH 49
#define ENOCSI 50
#define EL2HLT 51
#define EBADE 52
#define EBADR 53
#define EXFULL 54
#define ENOANO 55
#define EBADRQC 56
#define EBADSLT 57
#define EDEADLOCK EDEADLK
#define EBFONT 59
#define ENOSTR 60
#define ENODATA 61
#define ETIME 62
#define ENOSR 63
#define ENONET 64
#define ENOPKG 65
#define EREMOTE 66
#define ENOLINK 67
#define EADV 68
#define ESRMNT 69
#define ECOMM 70
#define EPROTO 71
#define EMULTIHOP 72
#define EDOTDOT 73
#define EBADMSG 74
#define EOVERFLOW 75
#define ENOTUNIQ 76
#define EBADFD 77
#define EREMCHG 78
#define ELIBACC 79
#define ELIBBAD 80
#define ELIBSCN 81
#define ELIBMAX 82
#define ELIBEXEC 83
#define EILSEQ 84
#define ERESTART 85
#define ESTRPIPE 86
#define EUSERS 87
#define ENOTSOCK 88
#define EDESTADDRREQ 89
#define EMSGSIZE 90
#define EPROTOTYPE 91
#define ENOPROTOOPT 92
#define EPROTONOSUPPORT 93
#define ESOCKTNOSUPPORT 94
#define EOPNOTSUPP 95
#define ENOTSUP EOPNOTSUPP
#define EPFNOSUPPORT 96
#define EAFNOSUPPORT 97
#define EADDRINUSE 98
#define EADDRNOTAVAIL 99
#define ENETDOWN 100
#define ENETUNREACH 101
#define ENETRESET 102
#define ECONNABORTED 103
#define ECONNRESET 104
#define ENOBUFS 105
#define EISCONN 106
#define ENOTCONN 107
#define ESHUTDOWN 108
#define ETOOMANYREFS 109
#define ETIMEDOUT 110
#define ECONNREFUSED 111
#define EHOSTDOWN 112
#define EHOSTUNREACH 113
#define EALREADY 114
#define EINPROGRESS 115
#define ESTALE 116
#define EUCLEAN 117
#define ENOTNAM 118
#define ENAVAIL 119
#define EISNAM 120
#define EREMOTEIO 121
#define EDQUOT 122
#define ENOMEDIUM 123
#define EMEDIUMTYPE 124
#define ECANCELED 125
#define ENOKEY 126
#define EKEYEXPIRED 127
#define EKEYREVOKED 128
#define EKEYREJECTED 129
#define EOWNERDEAD 130
#define ENOTRECOVERABLE 131
#define ERFKILL 132
#define EHWPOISON 133
# 11 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/errno.h" 2 3 4

int *__errno_location(void);
#define errno (*__errno_location())


extern char *program_invocation_short_name, *program_invocation_name;



}
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 2 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/unistd.h" 1 3 4

#define _UNISTD_H 


extern "C" {




#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2

#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2


#define NULL 0L




#define __NEED_size_t 
#define __NEED_ssize_t 
#define __NEED_uid_t 
#define __NEED_gid_t 
#define __NEED_off_t 
#define __NEED_pid_t 
#define __NEED_intptr_t 
#define __NEED_useconds_t 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 119 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef long ssize_t;
#define __DEFINED_ssize_t 
# 206 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef long off_t;
#define __DEFINED_off_t 
# 279 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef int pid_t;
#define __DEFINED_pid_t 








typedef unsigned uid_t;
#define __DEFINED_uid_t 



typedef unsigned gid_t;
#define __DEFINED_gid_t 








typedef unsigned useconds_t;
#define __DEFINED_useconds_t 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/unistd.h" 2 3 4

int pipe(int [2]);
int pipe2(int [2], int);
int close(int);
int posix_close(int, int);
int dup(int);
int dup2(int, int);
int dup3(int, int, int);
off_t lseek(int, off_t, int);
int fsync(int);
int fdatasync(int);

ssize_t read(int, void *, size_t);
ssize_t write(int, const void *, size_t);
ssize_t pread(int, void *, size_t, off_t);
ssize_t pwrite(int, const void *, size_t, off_t);

int chown(const char *, uid_t, gid_t);
int fchown(int, uid_t, gid_t);
int lchown(const char *, uid_t, gid_t);
int fchownat(int, const char *, uid_t, gid_t, int);

int link(const char *, const char *);
int linkat(int, const char *, int, const char *, int);
int symlink(const char *, const char *);
int symlinkat(const char *, int, const char *);
ssize_t readlink(const char *__restrict, char *__restrict, size_t);
ssize_t readlinkat(int, const char *__restrict, char *__restrict, size_t);
int unlink(const char *);
int unlinkat(int, const char *, int);
int rmdir(const char *);
int truncate(const char *, off_t);
int ftruncate(int, off_t);

#define F_OK 0
#define R_OK 4
#define W_OK 2
#define X_OK 1

int access(const char *, int);
int faccessat(int, const char *, int, int);

int chdir(const char *);
int fchdir(int);
char *getcwd(char *, size_t);

unsigned alarm(unsigned);
unsigned sleep(unsigned);
int pause(void);

pid_t fork(void);
int execve(const char *, char *const [], char *const []);
int execv(const char *, char *const []);
int execle(const char *, const char *, ...);
int execl(const char *, const char *, ...);
int execvp(const char *, char *const []);
int execlp(const char *, const char *, ...);
int fexecve(int, char *const [], char *const []);
__attribute__((__noreturn__)) void _exit(int);

pid_t getpid(void);
pid_t getppid(void);
pid_t getpgrp(void);
pid_t getpgid(pid_t);
int setpgid(pid_t, pid_t);
pid_t setsid(void);
pid_t getsid(pid_t);
char *ttyname(int);
int ttyname_r(int, char *, size_t);
int isatty(int);
pid_t tcgetpgrp(int);
int tcsetpgrp(int, pid_t);

uid_t getuid(void);
uid_t geteuid(void);
gid_t getgid(void);
gid_t getegid(void);
int getgroups(int, gid_t []);
int setuid(uid_t);
int seteuid(uid_t);
int setgid(gid_t);
int setegid(gid_t);

char *getlogin(void);
int getlogin_r(char *, size_t);
int gethostname(char *, size_t);
char *ctermid(char *);

int getopt(int, char * const [], const char *);
extern char *optarg;
extern int optind, opterr, optopt;

long pathconf(const char *, int);
long fpathconf(int, int);
long sysconf(int);
size_t confstr(int, char *, size_t);

#define F_ULOCK 0
#define F_LOCK 1
#define F_TLOCK 2
#define F_TEST 3


int setreuid(uid_t, uid_t);
int setregid(gid_t, gid_t);
int lockf(int, int, off_t);
long gethostid(void);
int nice(int);
void sync(void);
pid_t setpgrp(void);
char *crypt(const char *, const char *);
void encrypt(char *, int);
void swab(const void *__restrict, void *__restrict, ssize_t);




int usleep(unsigned);
unsigned ualarm(unsigned, unsigned);



#define L_SET 0
#define L_INCR 1
#define L_XTND 2
int brk(void *);
void *sbrk(intptr_t);
pid_t vfork(void);
int vhangup(void);
int chroot(const char *);
int getpagesize(void);
int getdtablesize(void);
int sethostname(const char *, size_t);
int getdomainname(char *, size_t);
int setdomainname(const char *, size_t);
int setgroups(size_t, const gid_t *);
char *getpass(const char *);
int daemon(int, int);
void setusershell(void);
void endusershell(void);
char *getusershell(void);
int acct(const char *);
long syscall(long, ...);
int execvpe(const char *, char *const [], char *const []);
int issetugid(void);



extern char **environ;
int setresuid(uid_t, uid_t, uid_t);
int setresgid(gid_t, gid_t, gid_t);
int getresuid(uid_t *, uid_t *, uid_t *);
int getresgid(gid_t *, gid_t *, gid_t *);
char *get_current_dir_name(void);
int syncfs(int);
int euidaccess(const char *, int);
int eaccess(const char *, int);



#define lseek64 lseek
#define pread64 pread
#define pwrite64 pwrite
#define truncate64 truncate
#define ftruncate64 ftruncate
#define lockf64 lockf
#define off64_t off_t


#define POSIX_CLOSE_RESTART 0

#define _XOPEN_VERSION 700
#define _XOPEN_UNIX 1
#define _XOPEN_ENH_I18N 1

#define _POSIX_VERSION 200809L
#define _POSIX2_VERSION _POSIX_VERSION

#define _POSIX_ADVISORY_INFO _POSIX_VERSION
#define _POSIX_CHOWN_RESTRICTED 1
#define _POSIX_IPV6 _POSIX_VERSION
#define _POSIX_JOB_CONTROL 1
#define _POSIX_MAPPED_FILES _POSIX_VERSION
#define _POSIX_MEMLOCK _POSIX_VERSION
#define _POSIX_MEMLOCK_RANGE _POSIX_VERSION
#define _POSIX_MEMORY_PROTECTION _POSIX_VERSION
#define _POSIX_MESSAGE_PASSING _POSIX_VERSION
#define _POSIX_FSYNC _POSIX_VERSION
#define _POSIX_NO_TRUNC 1
#define _POSIX_RAW_SOCKETS _POSIX_VERSION
#define _POSIX_REALTIME_SIGNALS _POSIX_VERSION
#define _POSIX_REGEXP 1
#define _POSIX_SAVED_IDS 1
#define _POSIX_SHELL 1
#define _POSIX_SPAWN _POSIX_VERSION
#define _POSIX_VDISABLE 0

#define _POSIX_THREADS _POSIX_VERSION
#define _POSIX_THREAD_PROCESS_SHARED _POSIX_VERSION
#define _POSIX_THREAD_SAFE_FUNCTIONS _POSIX_VERSION
#define _POSIX_THREAD_ATTR_STACKADDR _POSIX_VERSION
#define _POSIX_THREAD_ATTR_STACKSIZE _POSIX_VERSION
#define _POSIX_THREAD_PRIORITY_SCHEDULING _POSIX_VERSION
#define _POSIX_THREAD_CPUTIME _POSIX_VERSION
#define _POSIX_TIMERS _POSIX_VERSION
#define _POSIX_TIMEOUTS _POSIX_VERSION
#define _POSIX_MONOTONIC_CLOCK _POSIX_VERSION
#define _POSIX_CPUTIME _POSIX_VERSION
#define _POSIX_CLOCK_SELECTION _POSIX_VERSION
#define _POSIX_BARRIERS _POSIX_VERSION
#define _POSIX_SPIN_LOCKS _POSIX_VERSION
#define _POSIX_READER_WRITER_LOCKS _POSIX_VERSION
#define _POSIX_ASYNCHRONOUS_IO _POSIX_VERSION
#define _POSIX_SEMAPHORES _POSIX_VERSION
#define _POSIX_SHARED_MEMORY_OBJECTS _POSIX_VERSION

#define _POSIX2_C_BIND _POSIX_VERSION


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/posix.h" 1 3 4
#define _POSIX_V6_LP64_OFF64 1
#define _POSIX_V7_LP64_OFF64 1
# 253 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/unistd.h" 2 3 4



#define _PC_LINK_MAX 0
#define _PC_MAX_CANON 1
#define _PC_MAX_INPUT 2
#define _PC_NAME_MAX 3
#define _PC_PATH_MAX 4
#define _PC_PIPE_BUF 5
#define _PC_CHOWN_RESTRICTED 6
#define _PC_NO_TRUNC 7
#define _PC_VDISABLE 8
#define _PC_SYNC_IO 9
#define _PC_ASYNC_IO 10
#define _PC_PRIO_IO 11
#define _PC_SOCK_MAXBUF 12
#define _PC_FILESIZEBITS 13
#define _PC_REC_INCR_XFER_SIZE 14
#define _PC_REC_MAX_XFER_SIZE 15
#define _PC_REC_MIN_XFER_SIZE 16
#define _PC_REC_XFER_ALIGN 17
#define _PC_ALLOC_SIZE_MIN 18
#define _PC_SYMLINK_MAX 19
#define _PC_2_SYMLINKS 20

#define _SC_ARG_MAX 0
#define _SC_CHILD_MAX 1
#define _SC_CLK_TCK 2
#define _SC_NGROUPS_MAX 3
#define _SC_OPEN_MAX 4
#define _SC_STREAM_MAX 5
#define _SC_TZNAME_MAX 6
#define _SC_JOB_CONTROL 7
#define _SC_SAVED_IDS 8
#define _SC_REALTIME_SIGNALS 9
#define _SC_PRIORITY_SCHEDULING 10
#define _SC_TIMERS 11
#define _SC_ASYNCHRONOUS_IO 12
#define _SC_PRIORITIZED_IO 13
#define _SC_SYNCHRONIZED_IO 14
#define _SC_FSYNC 15
#define _SC_MAPPED_FILES 16
#define _SC_MEMLOCK 17
#define _SC_MEMLOCK_RANGE 18
#define _SC_MEMORY_PROTECTION 19
#define _SC_MESSAGE_PASSING 20
#define _SC_SEMAPHORES 21
#define _SC_SHARED_MEMORY_OBJECTS 22
#define _SC_AIO_LISTIO_MAX 23
#define _SC_AIO_MAX 24
#define _SC_AIO_PRIO_DELTA_MAX 25
#define _SC_DELAYTIMER_MAX 26
#define _SC_MQ_OPEN_MAX 27
#define _SC_MQ_PRIO_MAX 28
#define _SC_VERSION 29
#define _SC_PAGE_SIZE 30
#define _SC_PAGESIZE 30
#define _SC_RTSIG_MAX 31
#define _SC_SEM_NSEMS_MAX 32
#define _SC_SEM_VALUE_MAX 33
#define _SC_SIGQUEUE_MAX 34
#define _SC_TIMER_MAX 35
#define _SC_BC_BASE_MAX 36
#define _SC_BC_DIM_MAX 37
#define _SC_BC_SCALE_MAX 38
#define _SC_BC_STRING_MAX 39
#define _SC_COLL_WEIGHTS_MAX 40
#define _SC_EXPR_NEST_MAX 42
#define _SC_LINE_MAX 43
#define _SC_RE_DUP_MAX 44
#define _SC_2_VERSION 46
#define _SC_2_C_BIND 47
#define _SC_2_C_DEV 48
#define _SC_2_FORT_DEV 49
#define _SC_2_FORT_RUN 50
#define _SC_2_SW_DEV 51
#define _SC_2_LOCALEDEF 52
#define _SC_UIO_MAXIOV 60
#define _SC_IOV_MAX 60
#define _SC_THREADS 67
#define _SC_THREAD_SAFE_FUNCTIONS 68
#define _SC_GETGR_R_SIZE_MAX 69
#define _SC_GETPW_R_SIZE_MAX 70
#define _SC_LOGIN_NAME_MAX 71
#define _SC_TTY_NAME_MAX 72
#define _SC_THREAD_DESTRUCTOR_ITERATIONS 73
#define _SC_THREAD_KEYS_MAX 74
#define _SC_THREAD_STACK_MIN 75
#define _SC_THREAD_THREADS_MAX 76
#define _SC_THREAD_ATTR_STACKADDR 77
#define _SC_THREAD_ATTR_STACKSIZE 78
#define _SC_THREAD_PRIORITY_SCHEDULING 79
#define _SC_THREAD_PRIO_INHERIT 80
#define _SC_THREAD_PRIO_PROTECT 81
#define _SC_THREAD_PROCESS_SHARED 82
#define _SC_NPROCESSORS_CONF 83
#define _SC_NPROCESSORS_ONLN 84
#define _SC_PHYS_PAGES 85
#define _SC_AVPHYS_PAGES 86
#define _SC_ATEXIT_MAX 87
#define _SC_PASS_MAX 88
#define _SC_XOPEN_VERSION 89
#define _SC_XOPEN_XCU_VERSION 90
#define _SC_XOPEN_UNIX 91
#define _SC_XOPEN_CRYPT 92
#define _SC_XOPEN_ENH_I18N 93
#define _SC_XOPEN_SHM 94
#define _SC_2_CHAR_TERM 95
#define _SC_2_UPE 97
#define _SC_XOPEN_XPG2 98
#define _SC_XOPEN_XPG3 99
#define _SC_XOPEN_XPG4 100
#define _SC_NZERO 109
#define _SC_XBS5_ILP32_OFF32 125
#define _SC_XBS5_ILP32_OFFBIG 126
#define _SC_XBS5_LP64_OFF64 127
#define _SC_XBS5_LPBIG_OFFBIG 128
#define _SC_XOPEN_LEGACY 129
#define _SC_XOPEN_REALTIME 130
#define _SC_XOPEN_REALTIME_THREADS 131
#define _SC_ADVISORY_INFO 132
#define _SC_BARRIERS 133
#define _SC_CLOCK_SELECTION 137
#define _SC_CPUTIME 138
#define _SC_THREAD_CPUTIME 139
#define _SC_MONOTONIC_CLOCK 149
#define _SC_READER_WRITER_LOCKS 153
#define _SC_SPIN_LOCKS 154
#define _SC_REGEXP 155
#define _SC_SHELL 157
#define _SC_SPAWN 159
#define _SC_SPORADIC_SERVER 160
#define _SC_THREAD_SPORADIC_SERVER 161
#define _SC_TIMEOUTS 164
#define _SC_TYPED_MEMORY_OBJECTS 165
#define _SC_2_PBS 168
#define _SC_2_PBS_ACCOUNTING 169
#define _SC_2_PBS_LOCATE 170
#define _SC_2_PBS_MESSAGE 171
#define _SC_2_PBS_TRACK 172
#define _SC_SYMLOOP_MAX 173
#define _SC_STREAMS 174
#define _SC_2_PBS_CHECKPOINT 175
#define _SC_V6_ILP32_OFF32 176
#define _SC_V6_ILP32_OFFBIG 177
#define _SC_V6_LP64_OFF64 178
#define _SC_V6_LPBIG_OFFBIG 179
#define _SC_HOST_NAME_MAX 180
#define _SC_TRACE 181
#define _SC_TRACE_EVENT_FILTER 182
#define _SC_TRACE_INHERIT 183
#define _SC_TRACE_LOG 184

#define _SC_IPV6 235
#define _SC_RAW_SOCKETS 236
#define _SC_V7_ILP32_OFF32 237
#define _SC_V7_ILP32_OFFBIG 238
#define _SC_V7_LP64_OFF64 239
#define _SC_V7_LPBIG_OFFBIG 240
#define _SC_SS_REPL_MAX 241
#define _SC_TRACE_EVENT_NAME_MAX 242
#define _SC_TRACE_NAME_MAX 243
#define _SC_TRACE_SYS_MAX 244
#define _SC_TRACE_USER_EVENT_MAX 245
#define _SC_XOPEN_STREAMS 246
#define _SC_THREAD_ROBUST_PRIO_INHERIT 247
#define _SC_THREAD_ROBUST_PRIO_PROTECT 248

#define _CS_PATH 0
#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS 1
#define _CS_GNU_LIBC_VERSION 2
#define _CS_GNU_LIBPTHREAD_VERSION 3
#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS 4
#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS 5

#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS 1116
#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS 1117
#define _CS_POSIX_V6_ILP32_OFF32_LIBS 1118
#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS 1119
#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS 1120
#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS 1121
#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS 1122
#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS 1123
#define _CS_POSIX_V6_LP64_OFF64_CFLAGS 1124
#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS 1125
#define _CS_POSIX_V6_LP64_OFF64_LIBS 1126
#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS 1127
#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS 1128
#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS 1129
#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS 1130
#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS 1131
#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS 1132
#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS 1133
#define _CS_POSIX_V7_ILP32_OFF32_LIBS 1134
#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS 1135
#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS 1136
#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS 1137
#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS 1138
#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS 1139
#define _CS_POSIX_V7_LP64_OFF64_CFLAGS 1140
#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS 1141
#define _CS_POSIX_V7_LP64_OFF64_LIBS 1142
#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS 1143
#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS 1144
#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS 1145
#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS 1146
#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS 1147
#define _CS_V6_ENV 1148
#define _CS_V7_ENV 1149


}
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/stat.h" 1 3 4

#define _SYS_STAT_H 

extern "C" {




#define __NEED_dev_t 
#define __NEED_ino_t 
#define __NEED_mode_t 
#define __NEED_nlink_t 
#define __NEED_uid_t 
#define __NEED_gid_t 
#define __NEED_off_t 
#define __NEED_time_t 
#define __NEED_blksize_t 
#define __NEED_blkcnt_t 
#define __NEED_struct_timespec 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef int blksize_t;
#define __DEFINED_blksize_t 



typedef unsigned int nlink_t;
#define __DEFINED_nlink_t 
# 58 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef long time_t;
#define __DEFINED_time_t 
# 196 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned mode_t;
#define __DEFINED_mode_t 
# 211 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long ino_t;
#define __DEFINED_ino_t 



typedef unsigned long dev_t;
#define __DEFINED_dev_t 








typedef long blkcnt_t;
#define __DEFINED_blkcnt_t 
# 273 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
struct timespec { time_t tv_sec; long tv_nsec; };
#define __DEFINED_struct_timespec 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 22 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/stat.h" 2 3 4

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/stat.h" 1 3 4
struct stat {
 dev_t st_dev;
 ino_t st_ino;
 mode_t st_mode;
 nlink_t st_nlink;
 uid_t st_uid;
 gid_t st_gid;
 dev_t st_rdev;
 unsigned long __pad;
 off_t st_size;
 blksize_t st_blksize;
 int __pad2;
 blkcnt_t st_blocks;
 struct timespec st_atim;
 struct timespec st_mtim;
 struct timespec st_ctim;
 unsigned __unused[2];
};
# 24 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/stat.h" 2 3 4

#define st_atime st_atim.tv_sec
#define st_mtime st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec

#define S_IFMT 0170000

#define S_IFDIR 0040000
#define S_IFCHR 0020000
#define S_IFBLK 0060000
#define S_IFREG 0100000
#define S_IFIFO 0010000
#define S_IFLNK 0120000
#define S_IFSOCK 0140000

#define S_TYPEISMQ(buf) 0
#define S_TYPEISSEM(buf) 0
#define S_TYPEISSHM(buf) 0
#define S_TYPEISTMO(buf) 0

#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
#define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR)
#define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK)
#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
#define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
#define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK)
#define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK)


#define S_ISUID 04000
#define S_ISGID 02000
#define S_ISVTX 01000
#define S_IRUSR 0400
#define S_IWUSR 0200
#define S_IXUSR 0100
#define S_IRWXU 0700
#define S_IRGRP 0040
#define S_IWGRP 0020
#define S_IXGRP 0010
#define S_IRWXG 0070
#define S_IROTH 0004
#define S_IWOTH 0002
#define S_IXOTH 0001
#define S_IRWXO 0007


#define UTIME_NOW 0x3fffffff
#define UTIME_OMIT 0x3ffffffe

int stat(const char *__restrict, struct stat *__restrict);
int fstat(int, struct stat *);
int lstat(const char *__restrict, struct stat *__restrict);
int fstatat(int, const char *__restrict, struct stat *__restrict, int);
int chmod(const char *, mode_t);
int fchmod(int, mode_t);
int fchmodat(int, const char *, mode_t, int);
mode_t umask(mode_t);
int mkdir(const char *, mode_t);
int mkfifo(const char *, mode_t);
int mkdirat(int, const char *, mode_t);
int mkfifoat(int, const char *, mode_t);


int mknod(const char *, mode_t, dev_t);
int mknodat(int, const char *, mode_t, dev_t);


int futimens(int, const struct timespec [2]);
int utimensat(int, const char *, const struct timespec [2], int);


int lchmod(const char *, mode_t);
#define S_IREAD S_IRUSR
#define S_IWRITE S_IWUSR
#define S_IEXEC S_IXUSR



#define stat64 stat
#define fstat64 fstat
#define lstat64 lstat
#define fstatat64 fstatat
#define blkcnt64_t blkcnt_t
#define fsblkcnt64_t fsblkcnt_t
#define fsfilcnt64_t fsfilcnt_t
#define ino64_t ino_t
#define off64_t off_t



}
# 44 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/types.h" 1 3 4

#define _SYS_TYPES_H 

extern "C" {




#define __NEED_ino_t 
#define __NEED_dev_t 
#define __NEED_uid_t 
#define __NEED_gid_t 
#define __NEED_mode_t 
#define __NEED_nlink_t 
#define __NEED_off_t 
#define __NEED_pid_t 
#define __NEED_size_t 
#define __NEED_ssize_t 
#define __NEED_time_t 
#define __NEED_timer_t 
#define __NEED_clockid_t 

#define __NEED_blkcnt_t 
#define __NEED_fsblkcnt_t 
#define __NEED_fsfilcnt_t 

#define __NEED_id_t 
#define __NEED_key_t 
#define __NEED_clock_t 
#define __NEED_suseconds_t 
#define __NEED_blksize_t 

#define __NEED_pthread_t 
#define __NEED_pthread_attr_t 
#define __NEED_pthread_mutexattr_t 
#define __NEED_pthread_condattr_t 
#define __NEED_pthread_rwlockattr_t 
#define __NEED_pthread_barrierattr_t 
#define __NEED_pthread_mutex_t 
#define __NEED_pthread_cond_t 
#define __NEED_pthread_rwlock_t 
#define __NEED_pthread_barrier_t 
#define __NEED_pthread_spinlock_t 
#define __NEED_pthread_key_t 
#define __NEED_pthread_once_t 
#define __NEED_useconds_t 


#define __NEED_int8_t 
#define __NEED_int16_t 
#define __NEED_int32_t 
#define __NEED_int64_t 
#define __NEED_u_int64_t 
#define __NEED_register_t 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef long suseconds_t;
#define __DEFINED_suseconds_t 




typedef struct { union { int __i[14]; volatile int __vi[14]; unsigned long __s[7]; } __u; } pthread_attr_t;
#define __DEFINED_pthread_attr_t 



typedef struct { union { int __i[10]; volatile int __vi[10]; volatile void *volatile __p[5]; } __u; } pthread_mutex_t;
#define __DEFINED_pthread_mutex_t 








typedef struct { union { int __i[12]; volatile int __vi[12]; void *__p[6]; } __u; } pthread_cond_t;
#define __DEFINED_pthread_cond_t 








typedef struct { union { int __i[14]; volatile int __vi[14]; void *__p[7]; } __u; } pthread_rwlock_t;
#define __DEFINED_pthread_rwlock_t 



typedef struct { union { int __i[8]; volatile int __vi[8]; void *__p[4]; } __u; } pthread_barrier_t;
#define __DEFINED_pthread_barrier_t 
# 134 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef long register_t;
#define __DEFINED_register_t 
# 185 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long u_int64_t;
#define __DEFINED_u_int64_t 
# 231 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long fsblkcnt_t;
#define __DEFINED_fsblkcnt_t 



typedef unsigned long fsfilcnt_t;
#define __DEFINED_fsfilcnt_t 
# 253 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef void * timer_t;
#define __DEFINED_timer_t 



typedef int clockid_t;
#define __DEFINED_clockid_t 



typedef long clock_t;
#define __DEFINED_clock_t 
# 284 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned id_t;
#define __DEFINED_id_t 
# 299 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef int key_t;
#define __DEFINED_key_t 
# 311 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long pthread_t;
#define __DEFINED_pthread_t 
# 323 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef int pthread_once_t;
#define __DEFINED_pthread_once_t 



typedef unsigned pthread_key_t;
#define __DEFINED_pthread_key_t 



typedef int pthread_spinlock_t;
#define __DEFINED_pthread_spinlock_t 



typedef struct { unsigned __attr; } pthread_mutexattr_t;
#define __DEFINED_pthread_mutexattr_t 



typedef struct { unsigned __attr; } pthread_condattr_t;
#define __DEFINED_pthread_condattr_t 



typedef struct { unsigned __attr; } pthread_barrierattr_t;
#define __DEFINED_pthread_barrierattr_t 



typedef struct { unsigned __attr[2]; } pthread_rwlockattr_t;
#define __DEFINED_pthread_rwlockattr_t 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 58 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/types.h" 2 3 4


typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned u_int32_t;
typedef char *caddr_t;
typedef unsigned char u_char;
typedef unsigned short u_short, ushort;
typedef unsigned u_int, uint;
typedef unsigned long u_long, ulong;
typedef long long quad_t;
typedef unsigned long long u_quad_t;

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/endian.h" 1 3 4

#define _ENDIAN_H 



#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#define __PDP_ENDIAN 3412


#define __BYTE_ORDER __BYTE_ORDER__






#define BIG_ENDIAN __BIG_ENDIAN
#define LITTLE_ENDIAN __LITTLE_ENDIAN
#define PDP_ENDIAN __PDP_ENDIAN
#define BYTE_ORDER __BYTE_ORDER



static inline uint16_t __bswap16(uint16_t __x)
{
 return __x<<8 | __x>>8;
}

static inline uint32_t __bswap32(uint32_t __x)
{
 return __x>>24 | __x>>8&0xff00 | __x<<8&0xff0000 | __x<<24;
}

static inline uint64_t __bswap64(uint64_t __x)
{
 return __bswap32(__x)+0ULL<<32 | __bswap32(__x>>32);
}


#define htobe16(x) __bswap16(x)
#define be16toh(x) __bswap16(x)
#define betoh16(x) __bswap16(x)
#define htobe32(x) __bswap32(x)
#define be32toh(x) __bswap32(x)
#define betoh32(x) __bswap32(x)
#define htobe64(x) __bswap64(x)
#define be64toh(x) __bswap64(x)
#define betoh64(x) __bswap64(x)
#define htole16(x) (uint16_t)(x)
#define le16toh(x) (uint16_t)(x)
#define letoh16(x) (uint16_t)(x)
#define htole32(x) (uint32_t)(x)
#define le32toh(x) (uint32_t)(x)
#define letoh32(x) (uint32_t)(x)
#define htole64(x) (uint64_t)(x)
#define le64toh(x) (uint64_t)(x)
#define letoh64(x) (uint64_t)(x)
# 71 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/types.h" 2 3 4
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/select.h" 1 3 4

#define _SYS_SELECT_H 

extern "C" {




#define __NEED_size_t 
#define __NEED_time_t 
#define __NEED_suseconds_t 
#define __NEED_struct_timeval 
#define __NEED_struct_timespec 
#define __NEED_sigset_t 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 268 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
struct timeval { time_t tv_sec; suseconds_t tv_usec; };
#define __DEFINED_struct_timeval 
# 377 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef struct __sigset_t { unsigned long __bits[128/sizeof(long)]; } sigset_t;
#define __DEFINED_sigset_t 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 17 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/select.h" 2 3 4

#define FD_SETSIZE 1024

typedef unsigned long fd_mask;

typedef struct {
 unsigned long fds_bits[1024 / 8 / sizeof(long)];
} fd_set;

#define FD_ZERO(s) do { int __i; unsigned long *__b=(s)->fds_bits; for(__i=sizeof (fd_set)/sizeof (long); __i; __i--) *__b++=0; } while(0)
#define FD_SET(d,s) ((s)->fds_bits[(d)/(8*sizeof(long))] |= (1UL<<((d)%(8*sizeof(long)))))
#define FD_CLR(d,s) ((s)->fds_bits[(d)/(8*sizeof(long))] &= ~(1UL<<((d)%(8*sizeof(long)))))
#define FD_ISSET(d,s) !!((s)->fds_bits[(d)/(8*sizeof(long))] & (1UL<<((d)%(8*sizeof(long)))))

int select (int, fd_set *__restrict, fd_set *__restrict, fd_set *__restrict, struct timeval *__restrict);
int pselect (int, fd_set *__restrict, fd_set *__restrict, fd_set *__restrict, const struct timespec *__restrict, const sigset_t *__restrict);


#define NFDBITS (8*(int)sizeof(long))



}
# 72 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/types.h" 2 3 4
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/sysmacros.h" 1 3 4

#define _SYS_SYSMACROS_H 

#define major(x) ((unsigned)( (((x)>>31>>1) & 0xfffff000) | (((x)>>8) & 0x00000fff) ))

#define minor(x) ((unsigned)( (((x)>>12) & 0xffffff00) | ((x) & 0x000000ff) ))


#define makedev(x,y) ( (((x)&0xfffff000ULL) << 32) | (((x)&0x00000fffULL) << 8) | (((y)&0xffffff00ULL) << 12) | (((y)&0x000000ffULL)) )
# 73 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/types.h" 2 3 4



#define blkcnt64_t blkcnt_t
#define fsblkcnt64_t fsblkcnt_t
#define fsfilcnt64_t fsfilcnt_t
#define ino64_t ino_t
#define off64_t off_t



}
# 45 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 2 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/uio.h" 1 3 4

#define _SYS_UIO_H 


extern "C" {




#define __NEED_size_t 
#define __NEED_ssize_t 
#define __NEED_struct_iovec 


#define __NEED_off_t 



#define __NEED_pid_t 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 383 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
struct iovec { void *iov_base; size_t iov_len; };
#define __DEFINED_struct_iovec 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sys/uio.h" 2 3 4

#define UIO_MAXIOV 1024

ssize_t readv (int, const struct iovec *, int);
ssize_t writev (int, const struct iovec *, int);


ssize_t preadv (int, const struct iovec *, int, off_t);
ssize_t pwritev (int, const struct iovec *, int, off_t);

#define preadv64 preadv
#define pwritev64 pwritev
#define off64_t off_t




ssize_t process_vm_writev(pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long);
ssize_t process_vm_readv(pid_t, const struct iovec *, unsigned long, const struct iovec *, unsigned long, unsigned long);



}
# 49 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 2 3


namespace kj {
namespace miniposix {
# 93 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 3
using ::ssize_t;
using ::read;
using ::write;
using ::close;
# 113 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 3
using ::pipe;
using ::mkdir;

inline size_t iovMax(size_t count) {
# 128 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 3
  return 1024;
# 145 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/miniposix.h" 3
}



}
}
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 3
#define _GLIBCXX_UNORDERED_MAP 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 3





# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 1 3
# 56 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
#define _GLIBCXX_UTILITY 1
# 59 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
# 69 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_relops.h" 1 3
# 65 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_relops.h" 3
#define _STL_RELOPS_H 1

namespace std __attribute__ ((__visibility__ ("default")))
{
  namespace rel_ops
  {
# 85 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 98 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 111 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 124 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }


  }

}
# 70 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_pair.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_pair.h" 3
#define _STL_PAIR_H 1


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/move.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/move.h" 3
#define _MOVE_H 1



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/concept_check.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/concept_check.h" 3
#define _CONCEPT_CHECK_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/concept_check.h" 3
# 48 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/concept_check.h" 3
#define __glibcxx_function_requires(...) 
#define __glibcxx_class_requires(_a,_b) 
#define __glibcxx_class_requires2(_a,_b,_c) 
#define __glibcxx_class_requires3(_a,_b,_c,_d) 
#define __glibcxx_class_requires4(_a,_b,_c,_d,_e) 
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
#define _GLIBCXX_TYPE_TRAITS 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
namespace std
{
  typedef unsigned short uint_least16_t;
  typedef unsigned int uint_least32_t;
}





namespace std __attribute__ ((__visibility__ ("default")))
{
# 68 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 { 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>;
# 103 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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 integral_constant<bool, !_Pp::value>
    { };
# 195 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 { };




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

  template<>
    struct __is_integral_helper<unsigned __int128>
    : public true_type { };
# 327 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 { };
# 355 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 >
    struct is_function<_Res(_ArgTypes...) >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) const >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) const & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) const && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) const >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) const & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) const && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) volatile >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) volatile & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) volatile && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) volatile >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) volatile & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) volatile && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) const volatile >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) const volatile & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes...) const volatile && >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) const volatile >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) const volatile & >
    : public true_type { };

  template<typename _Res, typename... _ArgTypes >
    struct is_function<_Res(_ArgTypes......) const volatile && >
    : public true_type { };

#define __cpp_lib_is_null_pointer 201309

 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 >
    struct __is_referenceable<_Res(_Args...) >
    : public true_type
    { };

  template<typename _Res, typename... _Args >
    struct __is_referenceable<_Res(_Args......) >
    : 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)>
    { };
# 727 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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>>>
    { };




  template<typename>
    struct add_rvalue_reference;





  template<typename _Tp>
    typename add_rvalue_reference<_Tp>::type declval() noexcept;

  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
    { };
# 939 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  struct __do_is_static_castable_impl
  {
    template<typename _From, typename _To, typename
             = decltype(static_cast<_To>(declval<_From>()))>
      static true_type __test(int);

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

  template<typename _From, typename _To>
    struct __is_static_castable_impl
    : public __do_is_static_castable_impl
    {
      typedef decltype(__test<_From, _To>(0)) type;
    };

  template<typename _From, typename _To>
    struct __is_static_castable_safe
    : public __is_static_castable_impl<_From, _To>::type
    { };


  template<typename _From, typename _To>
    struct __is_static_castable
    : public integral_constant<bool, (__is_static_castable_safe<
          _From, _To>::value)>
    { };






  struct __do_is_direct_constructible_impl
  {
    template<typename _Tp, typename _Arg, typename
      = decltype(::new _Tp(declval<_Arg>()))>
      static true_type __test(int);

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

  template<typename _Tp, typename _Arg>
    struct __is_direct_constructible_impl
    : public __do_is_direct_constructible_impl
    {
      typedef decltype(__test<_Tp, _Arg>(0)) type;
    };

  template<typename _Tp, typename _Arg>
    struct __is_direct_constructible_new_safe
    : public __and_<is_destructible<_Tp>,
                    __is_direct_constructible_impl<_Tp, _Arg>>
    { };

  template<typename, typename>
    struct is_same;

  template<typename, typename>
    struct is_base_of;

  template<typename>
    struct remove_reference;

  template<typename _From, typename _To, bool
           = __not_<__or_<is_void<_From>,
                          is_function<_From>>>::value>
    struct __is_base_to_derived_ref;

  template<typename _Tp, typename... _Args>
    struct is_constructible;



  template<typename _From, typename _To>
    struct __is_base_to_derived_ref<_From, _To, true>
    {
      typedef typename remove_cv<typename remove_reference<_From
        >::type>::type __src_t;
      typedef typename remove_cv<typename remove_reference<_To
        >::type>::type __dst_t;
      typedef __and_<__not_<is_same<__src_t, __dst_t>>,
       is_base_of<__src_t, __dst_t>,
       __not_<is_constructible<__dst_t, _From>>> type;
      static constexpr bool value = type::value;
    };

  template<typename _From, typename _To>
    struct __is_base_to_derived_ref<_From, _To, false>
    : public false_type
    { };

  template<typename _From, typename _To, bool
           = __and_<is_lvalue_reference<_From>,
                    is_rvalue_reference<_To>>::value>
    struct __is_lvalue_to_rvalue_ref;



  template<typename _From, typename _To>
    struct __is_lvalue_to_rvalue_ref<_From, _To, true>
    {
      typedef typename remove_cv<typename remove_reference<
        _From>::type>::type __src_t;
      typedef typename remove_cv<typename remove_reference<
        _To>::type>::type __dst_t;
      typedef __and_<__not_<is_function<__src_t>>,
        __or_<is_same<__src_t, __dst_t>,
      is_base_of<__dst_t, __src_t>>> type;
      static constexpr bool value = type::value;
    };

  template<typename _From, typename _To>
    struct __is_lvalue_to_rvalue_ref<_From, _To, false>
    : public false_type
    { };







  template<typename _Tp, typename _Arg>
    struct __is_direct_constructible_ref_cast
    : public __and_<__is_static_castable<_Arg, _Tp>,
                    __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
                                 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
                   >>>
    { };

  template<typename _Tp, typename _Arg>
    struct __is_direct_constructible_new
    : public conditional<is_reference<_Tp>::value,
    __is_direct_constructible_ref_cast<_Tp, _Arg>,
    __is_direct_constructible_new_safe<_Tp, _Arg>
    >::type
    { };

  template<typename _Tp, typename _Arg>
    struct __is_direct_constructible
    : public __is_direct_constructible_new<_Tp, _Arg>::type
    { };






  struct __do_is_nary_constructible_impl
  {
    template<typename _Tp, typename... _Args, typename
             = decltype(_Tp(declval<_Args>()...))>
      static true_type __test(int);

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

  template<typename _Tp, typename... _Args>
    struct __is_nary_constructible_impl
    : public __do_is_nary_constructible_impl
    {
      typedef decltype(__test<_Tp, _Args...>(0)) type;
    };

  template<typename _Tp, typename... _Args>
    struct __is_nary_constructible
    : public __is_nary_constructible_impl<_Tp, _Args...>::type
    {
      static_assert(sizeof...(_Args) > 1,
                    "Only useful for > 1 arguments");
    };

  template<typename _Tp, typename... _Args>
    struct __is_constructible_impl
    : public __is_nary_constructible<_Tp, _Args...>
    { };

  template<typename _Tp, typename _Arg>
    struct __is_constructible_impl<_Tp, _Arg>
    : public __is_direct_constructible<_Tp, _Arg>
    { };

  template<typename _Tp>
    struct __is_constructible_impl<_Tp>
    : public is_default_constructible<_Tp>
    { };


  template<typename _Tp, typename... _Args>
    struct is_constructible
    : public __is_constructible_impl<_Tp, _Args...>::type
    { };

  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>
    class __is_assignable_helper
    {
      template<typename _Tp1, typename _Up1,
        typename = decltype(declval<_Tp1>() = declval<_Up1>())>
 static true_type
 __test(int);

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

    public:
      typedef decltype(__test<_Tp, _Up>(0)) type;
    };


  template<typename _Tp, typename _Up>
    struct is_assignable
      : public __is_assignable_helper<_Tp, _Up>::type
    { };

  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 __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
   __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>
    struct is_trivially_copy_constructible
    : public __and_<is_copy_constructible<_Tp>,
      integral_constant<bool,
   __is_trivially_constructible(_Tp, const _Tp&)>>
    { };


  template<typename _Tp>
    struct is_trivially_move_constructible
    : public __and_<is_move_constructible<_Tp>,
      integral_constant<bool,
   __is_trivially_constructible(_Tp, _Tp&&)>>
    { };


  template<typename _Tp, typename _Up>
    struct is_trivially_assignable
    : public __and_<is_assignable<_Tp, _Up>,
      integral_constant<bool,
   __is_trivially_assignable(_Tp, _Up)>>
    { };


  template<typename _Tp>
    struct is_trivially_copy_assignable
    : public __and_<is_copy_assignable<_Tp>,
      integral_constant<bool,
   __is_trivially_assignable(_Tp&, const _Tp&)>>
    { };


  template<typename _Tp>
    struct is_trivially_move_assignable
    : public __and_<is_move_assignable<_Tp>,
      integral_constant<bool,
   __is_trivially_assignable(_Tp&, _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;
    };
# 1630 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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>
    { };
# 1687 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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; };
# 1753 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  template<>
    struct __make_unsigned<__int128>
    { typedef unsigned __int128 __type; };
# 1774 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; };


  template<>
    struct __make_signed<wchar_t> : __make_signed<unsigned int>
    { };



  template<>
    struct __make_signed<char16_t> : __make_signed<uint_least16_t>
    { };
  template<>
    struct __make_signed<char32_t> : __make_signed<uint_least32_t>
    { };



  template<>
    struct __make_signed<unsigned __int128>
    { typedef __int128 __type; };
# 1893 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>;
# 1943 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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; };
# 1980 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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>
    { };
# 2019 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  template<std::size_t _Len>
    struct __aligned_storage_msa
    {
      union __type
      {
 unsigned char __data[_Len];
 struct __attribute__((__aligned__)) { } __align;
      };
    };
# 2039 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    };
# 2078 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      static typename add_rvalue_reference<_Tp>::type __delegate();
    };

  template<typename _Tp>
    inline typename add_rvalue_reference<_Tp>::type
    declval() noexcept
    {
      static_assert(__declval_protector<_Tp>::__stop,
      "declval() must not be used!");
      return __declval_protector<_Tp>::__delegate();
    }


  template<typename _Signature>
    class result_of;



#define __cpp_lib_result_of_sfinae 201210

 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...>
    { };
# 2498 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  template<typename...> using __void_t = void;


#define __cpp_lib_void_t 201411

 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;







#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) template<typename _Tp, typename = __void_t<>> struct __has_##_NTYPE : false_type { }; template<typename _Tp> struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> : true_type { };
# 2551 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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
    { };


#define __cpp_lib_is_swappable 201603



 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
    { };
# 2668 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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
    { };
# 2756 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
  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;
  };
# 3090 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/type_traits" 3
}
# 55 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/move.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 71 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 { };
# 115 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 135 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/move.h" 3
  template<typename _Tp>
    inline _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;
    }



}

#define _GLIBCXX_MOVE(__val) std::move(__val)
#define _GLIBCXX_FORWARD(_Tp,__val) std::forward<_Tp>(__val)





namespace std __attribute__ ((__visibility__ ("default")))
{
# 181 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/move.h" 3
  template<typename _Tp>
    inline

    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
         is_move_constructible<_Tp>,
         is_move_assignable<_Tp>>::value>::type
    swap(_Tp& __a, _Tp& __b)
    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
             is_nothrow_move_assignable<_Tp>>::value)




    {



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




  template<typename _Tp, size_t _Nm>
    inline

    typename enable_if<__is_swappable<_Tp>::value>::type
    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
    noexcept(__is_nothrow_swappable<_Tp>::value)




    {
      for (size_t __n = 0; __n < _Nm; ++__n)
 swap(__a[__n], __b[__n]);
    }



}
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_pair.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 76 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_pair.h" 3
  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };


                    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>
    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 536 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_pair.h" 3
}
# 71 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 2 3
# 82 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp>
    struct tuple_size;





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

  template<typename _Tp>
    struct __tuple_size_cv_impl<_Tp, __void_t<decltype(tuple_size<_Tp>::value)>>
    : integral_constant<size_t, tuple_size<_Tp>::value> { };



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

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

  template<typename _Tp>
    struct tuple_size<const volatile _Tp> : __tuple_size_cv_impl<_Tp> { };
# 132 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
  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;
    };
# 167 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
  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<>
    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<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); }
# 287 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
  template<size_t... _Indexes> struct _Index_tuple { };


  template<typename _Itup1, typename _Itup2> struct _Itup_cat;

  template<size_t... _Ind1, size_t... _Ind2>
    struct _Itup_cat<_Index_tuple<_Ind1...>, _Index_tuple<_Ind2...>>
    {
      using __type = _Index_tuple<_Ind1..., (_Ind2 + sizeof...(_Ind1))...>;
    };


  template<size_t _Num>
    struct _Build_index_tuple
    : _Itup_cat<typename _Build_index_tuple<_Num / 2>::__type,
  typename _Build_index_tuple<_Num - _Num / 2>::__type>
    { };

  template<>
    struct _Build_index_tuple<1>
    {
      typedef _Index_tuple<0> __type;
    };

  template<>
    struct _Build_index_tuple<0>
    {
      typedef _Index_tuple<> __type;
    };
# 407 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/utility" 3
}
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 2 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 3
#define _GLIBCXX_TUPLE 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 3






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/array" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/array" 3
#define _GLIBCXX_ARRAY 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/array" 3






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/stdexcept" 1 3
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/stdexcept" 3
#define _GLIBCXX_STDEXCEPT 1
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/stdexcept" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 3
#define __EXCEPTION__ 
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 3

#pragma GCC visibility push(default)



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception.h" 1 3
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception.h" 3
#define __EXCEPTION_H 1
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception.h" 3

#pragma GCC visibility push(default)



extern "C++" {

namespace std
{
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception.h" 3
  class exception
  {
  public:
    exception() noexcept { }
    virtual ~exception() noexcept;



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

}

}

#pragma GCC visibility pop
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 3
  bool uncaught_exception() noexcept __attribute__ ((__pure__));


#define __cpp_lib_uncaught_exceptions 201411

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



}

namespace __gnu_cxx
{
# 132 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 3
  void __verbose_terminate_handler();


}

}

#pragma GCC visibility pop



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_ptr.h" 1 3
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_ptr.h" 3
#define _EXCEPTION_PTR_H 

#pragma GCC visibility push(default)



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_defines.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_defines.h" 3
#define _EXCEPTION_DEFINES_H 1
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_defines.h" 3
#define __try try
#define __catch(X) catch(X)
#define __throw_exception_again throw
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_ptr.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cxxabi_init_exception.h" 1 3
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cxxabi_init_exception.h" 3
#define _CXXABI_INIT_EXCEPTION_H 1
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cxxabi_init_exception.h" 3

#pragma GCC visibility push(default)


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot-native/usr/lib/clang/5.0.1/include/stddef.h" 1 3
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cxxabi_init_exception.h" 2 3



#define _GLIBCXX_CDTOR_CALLABI 
#define _GLIBCXX_HAVE_CDTOR_CALLABI 0






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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_ptr.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/typeinfo" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/typeinfo" 3
#define _TYPEINFO 
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/typeinfo" 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hash_bytes.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hash_bytes.h" 3
#define _HASH_BYTES_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/typeinfo" 2 3


#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 68 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/typeinfo" 3
#define __GXX_MERGED_TYPEINFO_NAMES 0







#define __GXX_TYPEINFO_EQUALITY_INLINE 1



namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const noexcept
    { return __name[0] == '*' ? __name + 1 : __name; }
# 115 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/exception_ptr.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/new" 1 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/new" 3
#define _NEW 
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/new" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 1 3
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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();
  };






  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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 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__));
# 168 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/new" 3
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 { }

}
# 216 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/new" 3
#pragma GCC visibility pop
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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();
 }



    }





  template<typename _Ex>
    exception_ptr
    copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__));

  template<typename _Ex>
    exception_ptr
    copy_exception(_Ex __ex) noexcept
    { return std::make_exception_ptr<_Ex>(__ex); }


}

}

#pragma GCC visibility pop
# 143 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/nested_exception.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/nested_exception.h" 3
#define _GLIBCXX_NESTED_EXCEPTION_H 1

#pragma GCC visibility push(default)








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>
    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>
    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
# 144 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/exception" 2 3
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/stdexcept" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 1 3
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 3
#define _GLIBCXX_STRING 1
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stringfwd.h" 1 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stringfwd.h" 3
#define _STRINGFWD_H 1
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stringfwd.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/memoryfwd.h" 1 3
# 44 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/memoryfwd.h" 3
#define _MEMORYFWD_H 1
# 47 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/memoryfwd.h" 3



namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/memoryfwd.h" 3
  template<typename>
    class allocator;

  template<>
    class allocator<void>;


  template<typename, typename>
    struct uses_allocator;




}
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stringfwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stringfwd.h" 3
  template<class _CharT>
    struct char_traits;

  template<> struct char_traits<char>;


  template<> struct char_traits<wchar_t>;




  template<> struct char_traits<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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/char_traits.h" 1 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/char_traits.h" 3
#define _CHAR_TRAITS_H 1
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/char_traits.h" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
#define _STL_ALGOBASE_H 1



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functexcept.h" 1 3
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functexcept.h" 3
#define _FUNCTEXCEPT_H 1




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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cpp_type_traits.h" 1 3
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cpp_type_traits.h" 3
#define _CPP_TYPE_TRAITS_H 1
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cpp_type_traits.h" 3
# 67 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    };

#define __INT_N(TYPE) template<> struct __is_integer<TYPE> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned TYPE> { enum { __value = 1 }; typedef __true_type __type; };
# 261 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cpp_type_traits.h" 3
template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type; };
# 273 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cpp_type_traits.h" 3
#undef __INT_N




 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/type_traits.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/type_traits.h" 3
#define _EXT_TYPE_TRAITS 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/numeric_traits.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/numeric_traits.h" 3
#define _EXT_NUMERIC_TRAITS 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/numeric_traits.h" 3




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




#define __glibcxx_signed(_Tp) ((_Tp)(-1) < 0)
#define __glibcxx_digits(_Tp) (sizeof(_Tp) * __CHAR_BIT__ - __glibcxx_signed(_Tp))


#define __glibcxx_min(_Tp) (__glibcxx_signed(_Tp) ? (_Tp)1 << __glibcxx_digits(_Tp) : (_Tp)0)


#define __glibcxx_max(_Tp) (__glibcxx_signed(_Tp) ? (((((_Tp)1 << (__glibcxx_digits(_Tp) - 1)) - 1) << 1) + 1) : ~(_Tp)0)



 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;

#undef __glibcxx_signed
#undef __glibcxx_digits
#undef __glibcxx_min
#undef __glibcxx_max

#define __glibcxx_floating(_Tp,_Fval,_Dval,_LDval) (std::__are_same<_Tp, float>::__value ? _Fval : std::__are_same<_Tp, double>::__value ? _Dval : _LDval)



#define __glibcxx_max_digits10(_Tp) (2 + __glibcxx_floating(_Tp, __FLT_MANT_DIG__, __DBL_MANT_DIG__, __LDBL_MANT_DIG__) * 643L / 2136)



#define __glibcxx_digits10(_Tp) __glibcxx_floating(_Tp, __FLT_DIG__, __DBL_DIG__, __LDBL_DIG__)


#define __glibcxx_max_exponent10(_Tp) __glibcxx_floating(_Tp, __FLT_MAX_10_EXP__, __DBL_MAX_10_EXP__, __LDBL_MAX_10_EXP__)



 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 : 113) * 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 : 33);
      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
    { };


}

#undef __glibcxx_floating
#undef __glibcxx_max_digits10
#undef __glibcxx_digits10
#undef __glibcxx_max_exponent10
# 64 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_types.h" 1 3
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_types.h" 3
#define _STL_ITERATOR_BASE_TYPES_H 1
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_types.h" 3







namespace std __attribute__ ((__visibility__ ("default")))
{
# 89 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 typename iterator_traits<_Iter>::iterator_category
    __iterator_category(const _Iter&)
    { return typename iterator_traits<_Iter>::iterator_category(); }
# 230 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_funcs.h" 1 3
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_funcs.h" 3
#define _STL_ITERATOR_BASE_FUNCS_H 1
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_funcs.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/debug/assertions.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/debug/assertions.h" 3
#define _GLIBCXX_DEBUG_ASSERTIONS_H 1



#define _GLIBCXX_DEBUG_ASSERT(_Condition) 
#define _GLIBCXX_DEBUG_PEDASSERT(_Condition) 
#define _GLIBCXX_DEBUG_ONLY(_Statement) 




#define __glibcxx_requires_non_empty_range(_First,_Last) 
#define __glibcxx_requires_nonempty() 
#define __glibcxx_requires_subscript(_N) 
# 66 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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
    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
    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    inline
    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 void
    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
    {


                                ;
      while (__n--)
 ++__i;
    }

  template<typename _BidirectionalIterator, typename _Distance>
    inline 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 void
    __advance(_RandomAccessIterator& __i, _Distance __n,
              random_access_iterator_tag)
    {



      __i += __n;
    }
# 195 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline void
    advance(_InputIterator& __i, _Distance __n)
    {

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



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



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

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



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




}
# 67 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 1 3
# 61 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
#define _STL_ITERATOR_H 1





# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/ptr_traits.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/ptr_traits.h" 3
#define _PTR_TRAITS_H 1





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


}
# 67 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 100 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 126 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
      reverse_iterator() : current() { }




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





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





      template<typename _Iter>

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




                           iterator_type
      base() const
      { return current; }
# 167 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
                           reference
      operator*() const
      {
 _Iterator __tmp = current;
 return *--__tmp;
      }






                           pointer
      operator->() const
      { return &(operator*()); }






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






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






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






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






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







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






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







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






                           reference
      operator[](difference_type __n) const
      { return *(*this + __n); }
    };
# 297 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
  template<typename _Iterator>
    inline bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return __x.base() == __y.base(); }

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

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

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

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

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



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

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

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

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

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

  template<typename _IteratorL, typename _IteratorR>
    inline bool
    operator>=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    { return !(__x < __y); }
# 387 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    inline 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 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 reverse_iterator<_Iterator>
    __make_reverse_iterator(_Iterator __i)
    { return reverse_iterator<_Iterator>(__i); }
# 422 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
  template<typename _Iterator>
    auto
    __niter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
    { return __make_reverse_iterator(__niter_base(__it.base())); }

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

  template<typename _Iterator>
    auto
    __miter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
    { return __make_reverse_iterator(__miter_base(__it.base())); }
# 451 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 543 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 638 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
    };
# 733 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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")))
{
# 757 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
    };
# 857 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }


}



namespace std __attribute__ ((__visibility__ ("default")))
{
# 1009 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;


      move_iterator()
      : _M_current() { }

      explicit
      move_iterator(iterator_type __i)
      : _M_current(__i) { }

      template<typename _Iter>

 move_iterator(const move_iterator<_Iter>& __i)
 : _M_current(__i.base()) { }

                           iterator_type
      base() const
      { return _M_current; }

                           reference
      operator*() const
      { return static_cast<reference>(*_M_current); }

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

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

                           move_iterator
      operator++(int)
      {
 move_iterator __tmp = *this;
 ++_M_current;
 return __tmp;
      }

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

                           move_iterator
      operator--(int)
      {
 move_iterator __tmp = *this;
 --_M_current;
 return __tmp;
      }

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

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

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

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

                           reference
      operator[](difference_type __n) const
      { return std::move(_M_current[__n]); }
    };




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

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

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

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

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

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

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

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

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

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

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

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


  template<typename _IteratorL, typename _IteratorR>
    inline 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 move_iterator<_Iterator>
    operator+(typename move_iterator<_Iterator>::difference_type __n,
       const move_iterator<_Iterator>& __x)
    { return __x + __n; }

  template<typename _Iterator>
    inline 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 _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 _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()); }


}

#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) std::__make_move_if_noexcept_iterator(_Iter)
# 68 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/debug/debug.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/debug/debug.h" 3
#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
# 48 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/debug/debug.h" 3
namespace std
{
  namespace __debug { }
}




namespace __gnu_debug
{
  using namespace std::__debug;
}



#define __glibcxx_requires_cond(_Cond,_Msg) 
#define __glibcxx_requires_valid_range(_First,_Last) 
#define __glibcxx_requires_sorted(_First,_Last) 
#define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) 
#define __glibcxx_requires_sorted_set(_First1,_Last1,_First2) 
#define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred) 
#define __glibcxx_requires_partitioned_lower(_First,_Last,_Value) 
#define __glibcxx_requires_partitioned_upper(_First,_Last,_Value) 
#define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred) 
#define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred) 
#define __glibcxx_requires_heap(_First,_Last) 
#define __glibcxx_requires_heap_pred(_First,_Last,_Pred) 
#define __glibcxx_requires_string(_String) 
#define __glibcxx_requires_string_len(_String,_Len) 
#define __glibcxx_requires_irreflexive(_First,_Last) 
#define __glibcxx_requires_irreflexive2(_First,_Last) 
#define __glibcxx_requires_irreflexive_pred(_First,_Last,_Pred) 
#define __glibcxx_requires_irreflexive_pred2(_First,_Last,_Pred) 
# 70 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/predefined_ops.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/predefined_ops.h" 3
#define _GLIBCXX_PREDEFINED_OPS_H 1

namespace __gnu_cxx
{
namespace __ops
{
  struct _Iter_less_iter
  {
    template<typename _Iterator1, typename _Iterator2>

      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 < *__it2; }
  };


  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
      _Iter_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      template<typename _Iterator1, typename _Iterator2>

        bool
        operator()(_Iterator1 __it1, _Iterator2 __it2)
        { return bool(_M_comp(*__it1, *__it2)); }
    };

  template<typename _Compare>

    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 118 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {
# 148 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
      swap(*__a, *__b);

    }
# 164 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
  template<typename _Tp>

    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {



      if (__b < __a)
 return __b;
      return __a;
    }
# 216 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
  template<typename _Tp>

    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {



      if (__a < __b)
 return __b;
      return __a;
    }
# 240 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>

    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__b, __a))
 return __b;
      return __a;
    }
# 262 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>

    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
    }

#define _GLIBCXX_MOVE3(_Tp,_Up,_Vp) std::move(_Tp, _Up, _Vp)




 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
    }

#define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::move_backward(_Tp, _Up, _Vp)




 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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, ++__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, ++__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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1039 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 1071 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 1201 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {
# 1215 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
                                                       ;
                                                       ;

      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
      std::__niter_base(__last1),
      std::__niter_base(__first2),
      std::__niter_base(__last2));
    }
# 1237 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
    }
# 1280 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 1313 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 1414 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algobase.h" 3
}
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/char_traits.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 1 3
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 3
#define _GLIBCXX_POSTYPES_H 1
# 39 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 3




# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/wchar.h" 1 3 4

#define _WCHAR_H 


extern "C" {




#define __NEED_FILE 
#define __NEED___isoc_va_list 
#define __NEED_size_t 
#define __NEED_wchar_t 
#define __NEED_wint_t 
#define __NEED_mbstate_t 



#define __NEED_locale_t 
#define __NEED_va_list 



#define __NEED_wctype_t 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long


typedef __builtin_va_list va_list;
#define __DEFINED_va_list 



typedef __builtin_va_list __isoc_va_list;
#define __DEFINED___isoc_va_list 
# 24 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned wint_t;
#define __DEFINED_wint_t 
# 247 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef unsigned long wctype_t;
#define __DEFINED_wctype_t 
# 359 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
typedef struct _IO_FILE FILE;
#define __DEFINED_FILE 




typedef struct __mbstate_t { unsigned __opaque1, __opaque2; } mbstate_t;
#define __DEFINED_mbstate_t 
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 28 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/wchar.h" 2 3 4


#define WCHAR_MAX (0xffffffffu+L'\0')
#define WCHAR_MIN (0+L'\0')






#define NULL 0L




#undef WEOF
#define WEOF 0xffffffffU

wchar_t *wcscpy (wchar_t *__restrict, const wchar_t *__restrict);
wchar_t *wcsncpy (wchar_t *__restrict, const wchar_t *__restrict, size_t);

wchar_t *wcscat (wchar_t *__restrict, const wchar_t *__restrict);
wchar_t *wcsncat (wchar_t *__restrict, const wchar_t *__restrict, size_t);

int wcscmp (const wchar_t *, const wchar_t *);
int wcsncmp (const wchar_t *, const wchar_t *, size_t);

int wcscoll(const wchar_t *, const wchar_t *);
size_t wcsxfrm (wchar_t *__restrict, const wchar_t *__restrict, size_t);

wchar_t *wcschr (const wchar_t *, wchar_t);
wchar_t *wcsrchr (const wchar_t *, wchar_t);

size_t wcscspn (const wchar_t *, const wchar_t *);
size_t wcsspn (const wchar_t *, const wchar_t *);
wchar_t *wcspbrk (const wchar_t *, const wchar_t *);

wchar_t *wcstok (wchar_t *__restrict, const wchar_t *__restrict, wchar_t **__restrict);

size_t wcslen (const wchar_t *);

wchar_t *wcsstr (const wchar_t *__restrict, const wchar_t *__restrict);
wchar_t *wcswcs (const wchar_t *, const wchar_t *);

wchar_t *wmemchr (const wchar_t *, wchar_t, size_t);
int wmemcmp (const wchar_t *, const wchar_t *, size_t);
wchar_t *wmemcpy (wchar_t *__restrict, const wchar_t *__restrict, size_t);
wchar_t *wmemmove (wchar_t *, const wchar_t *, size_t);
wchar_t *wmemset (wchar_t *, wchar_t, size_t);

wint_t btowc (int);
int wctob (wint_t);

int mbsinit (const mbstate_t *);
size_t mbrtowc (wchar_t *__restrict, const char *__restrict, size_t, mbstate_t *__restrict);
size_t wcrtomb (char *__restrict, wchar_t, mbstate_t *__restrict);

size_t mbrlen (const char *__restrict, size_t, mbstate_t *__restrict);

size_t mbsrtowcs (wchar_t *__restrict, const char **__restrict, size_t, mbstate_t *__restrict);
size_t wcsrtombs (char *__restrict, const wchar_t **__restrict, size_t, mbstate_t *__restrict);

float wcstof (const wchar_t *__restrict, wchar_t **__restrict);
double wcstod (const wchar_t *__restrict, wchar_t **__restrict);
long double wcstold (const wchar_t *__restrict, wchar_t **__restrict);

long wcstol (const wchar_t *__restrict, wchar_t **__restrict, int);
unsigned long wcstoul (const wchar_t *__restrict, wchar_t **__restrict, int);

long long wcstoll (const wchar_t *__restrict, wchar_t **__restrict, int);
unsigned long long wcstoull (const wchar_t *__restrict, wchar_t **__restrict, int);



int fwide (FILE *, int);


int wprintf (const wchar_t *__restrict, ...);
int fwprintf (FILE *__restrict, const wchar_t *__restrict, ...);
int swprintf (wchar_t *__restrict, size_t, const wchar_t *__restrict, ...);

int vwprintf (const wchar_t *__restrict, __isoc_va_list);
int vfwprintf (FILE *__restrict, const wchar_t *__restrict, __isoc_va_list);
int vswprintf (wchar_t *__restrict, size_t, const wchar_t *__restrict, __isoc_va_list);

int wscanf (const wchar_t *__restrict, ...);
int fwscanf (FILE *__restrict, const wchar_t *__restrict, ...);
int swscanf (const wchar_t *__restrict, const wchar_t *__restrict, ...);

int vwscanf (const wchar_t *__restrict, __isoc_va_list);
int vfwscanf (FILE *__restrict, const wchar_t *__restrict, __isoc_va_list);
int vswscanf (const wchar_t *__restrict, const wchar_t *__restrict, __isoc_va_list);

wint_t fgetwc (FILE *);
wint_t getwc (FILE *);
wint_t getwchar (void);

wint_t fputwc (wchar_t, FILE *);
wint_t putwc (wchar_t, FILE *);
wint_t putwchar (wchar_t);

wchar_t *fgetws (wchar_t *__restrict, int, FILE *__restrict);
int fputws (const wchar_t *__restrict, FILE *__restrict);

wint_t ungetwc (wint_t, FILE *);

struct tm;
size_t wcsftime (wchar_t *__restrict, size_t, const wchar_t *__restrict, const struct tm *__restrict);

#undef iswdigit


wint_t fgetwc_unlocked (FILE *);
wint_t getwc_unlocked (FILE *);
wint_t getwchar_unlocked (void);
wint_t fputwc_unlocked (wchar_t, FILE *);
wint_t putwc_unlocked (wchar_t, FILE *);
wint_t putwchar_unlocked (wchar_t);
wchar_t *fgetws_unlocked (wchar_t *__restrict, int, FILE *__restrict);
int fputws_unlocked (const wchar_t *__restrict, FILE *__restrict);



size_t wcsftime_l (wchar_t *__restrict, size_t, const wchar_t *__restrict, const struct tm *__restrict, locale_t);




FILE *open_wmemstream(wchar_t **, size_t *);
size_t mbsnrtowcs(wchar_t *__restrict, const char **__restrict, size_t, size_t, mbstate_t *__restrict);
size_t wcsnrtombs(char *__restrict, const wchar_t **__restrict, size_t, size_t, mbstate_t *__restrict);
wchar_t *wcsdup(const wchar_t *);
size_t wcsnlen (const wchar_t *, size_t);
wchar_t *wcpcpy (wchar_t *__restrict, const wchar_t *__restrict);
wchar_t *wcpncpy (wchar_t *__restrict, const wchar_t *__restrict, size_t);
int wcscasecmp(const wchar_t *, const wchar_t *);
int wcscasecmp_l(const wchar_t *, const wchar_t *, locale_t);
int wcsncasecmp(const wchar_t *, const wchar_t *, size_t);
int wcsncasecmp_l(const wchar_t *, const wchar_t *, size_t, locale_t);
int wcscoll_l(const wchar_t *, const wchar_t *, locale_t);
size_t wcsxfrm_l(wchar_t *__restrict, const wchar_t *__restrict, size_t, locale_t);



int wcwidth (wchar_t);
int wcswidth (const wchar_t *, size_t);
int iswalnum(wint_t);
int iswalpha(wint_t);
int iswblank(wint_t);
int iswcntrl(wint_t);
int iswdigit(wint_t);
int iswgraph(wint_t);
int iswlower(wint_t);
int iswprint(wint_t);
int iswpunct(wint_t);
int iswspace(wint_t);
int iswupper(wint_t);
int iswxdigit(wint_t);
int iswctype(wint_t, wctype_t);
wint_t towlower(wint_t);
wint_t towupper(wint_t);
wctype_t wctype(const char *);
# 198 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/wchar.h" 3 4
}
# 45 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 2 3



#define _GLIBCXX_CWCHAR 1
# 62 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 3
namespace std
{
  using ::mbstate_t;
}


#undef btowc
#undef fgetwc
#undef fgetws
#undef fputwc
#undef fputws
#undef fwide
#undef fwprintf
#undef fwscanf
#undef getwc
#undef getwchar
#undef mbrlen
#undef mbrtowc
#undef mbsinit
#undef mbsrtowcs
#undef putwc
#undef putwchar
#undef swprintf
#undef swscanf
#undef ungetwc
#undef vfwprintf

#undef vfwscanf

#undef vswprintf

#undef vswscanf

#undef vwprintf

#undef vwscanf

#undef wcrtomb
#undef wcscat
#undef wcschr
#undef wcscmp
#undef wcscoll
#undef wcscpy
#undef wcscspn
#undef wcsftime
#undef wcslen
#undef wcsncat
#undef wcsncmp
#undef wcsncpy
#undef wcspbrk
#undef wcsrchr
#undef wcsrtombs
#undef wcsspn
#undef wcsstr
#undef wcstod

#undef wcstof

#undef wcstok
#undef wcstol
#undef wcstoul
#undef wcsxfrm
#undef wctob
#undef wmemchr
#undef wmemcmp
#undef wmemcpy
#undef wmemmove
#undef wmemset
#undef wprintf
#undef wscanf



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


  using ::wint_t;

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

  using ::swprintf;

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

  using ::vfwscanf;


  using ::vswprintf;


  using ::vswscanf;

  using ::vwprintf;

  using ::vwscanf;

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

  using ::wcstof;

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


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

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

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

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

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



}



#undef wcstold
#undef wcstoll
#undef wcstoull

namespace __gnu_cxx
{





  using ::wcstold;
# 257 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;
}
# 277 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 2 3
# 68 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 88 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 3
  typedef long streamoff;
# 98 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 3
  typedef ptrdiff_t streamsize;
# 111 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 133 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/char_traits.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 3
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/char_traits.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    };
# 82 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 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 int
      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

      static std::size_t
      length(const char_type* __s);

      static 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>
                         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>
                         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>
                         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")))
{
# 228 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 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 int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;
 return __builtin_memcmp(__s1, __s2, __n);
      }

      static size_t
      length(const char_type* __s)
      { return __builtin_strlen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __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 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 int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;
 return wmemcmp(__s1, __s2, __n);
      }

      static size_t
      length(const char_type* __s)
      { return wcslen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;
 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdint" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdint" 3
#define _GLIBCXX_CSTDINT 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdint" 3
# 46 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdint" 3
namespace std
{
  using ::int8_t;
  using ::int16_t;
  using ::int32_t;
  using ::int64_t;

  using ::int_fast8_t;
  using ::int_fast16_t;
  using ::int_fast32_t;
  using ::int_fast64_t;

  using ::int_least8_t;
  using ::int_least16_t;
  using ::int_least32_t;
  using ::int_least64_t;

  using ::intmax_t;
  using ::intptr_t;

  using ::uint8_t;
  using ::uint16_t;
  using ::uint32_t;
  using ::uint64_t;

  using ::uint_fast8_t;
  using ::uint_fast16_t;
  using ::uint_fast32_t;
  using ::uint_fast64_t;

  using ::uint_least8_t;
  using ::uint_least16_t;
  using ::uint_least32_t;
  using ::uint_least64_t;

  using ::uintmax_t;
  using ::uintptr_t;
}
# 423 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 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 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 size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static 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; }
    };

  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 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 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 size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/allocator.h" 1 3
# 44 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/allocator.h" 3
#define _ALLOCATOR_H 1


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++allocator.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++allocator.h" 3
#define _GLIBCXX_CXX_ALLOCATOR_H 1


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/new_allocator.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/new_allocator.h" 3
#define _NEW_ALLOCATOR_H 1
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/new_allocator.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


  using std::size_t;
  using std::ptrdiff_t;
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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* = 0)
      {
 if (__n > this->max_size())
   std::__throw_bad_alloc();
# 111 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/new_allocator.h" 3
 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
      }


      void
      deallocate(pointer __p, size_type)
      {







 ::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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++allocator.h" 2 3


namespace std
{
# 47 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++allocator.h" 3
  template<typename _Tp>
    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
}
# 47 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/allocator.h" 2 3





#define __cpp_lib_incomplete_container_elements 201505

#define __cpp_lib_allocator_is_always_equal 201411


namespace std __attribute__ ((__visibility__ ("default")))
{
# 67 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/allocator.h" 3
  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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }






  extern template class allocator<char>;
  extern template class allocator<wchar_t>;



#undef __allocator_base


 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/localefwd.h" 1 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/localefwd.h" 3
#define _LOCALE_FWD_H 1
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/localefwd.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++locale.h" 1 3
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++locale.h" 3
#define _GLIBCXX_CXX_LOCALE_H 1
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++locale.h" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/clocale" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/clocale" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/locale.h" 1 3 4

#define _LOCALE_H 


extern "C" {





#define NULL 0L




#define LC_CTYPE 0
#define LC_NUMERIC 1
#define LC_TIME 2
#define LC_COLLATE 3
#define LC_MONETARY 4
#define LC_MESSAGES 5
#define LC_ALL 6

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


char *setlocale (int, const char *);
struct lconv *localeconv(void);





#define __NEED_locale_t 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/locale.h" 2 3 4

#define LC_GLOBAL_LOCALE ((locale_t)-1)

#define LC_CTYPE_MASK (1<<LC_CTYPE)
#define LC_NUMERIC_MASK (1<<LC_NUMERIC)
#define LC_TIME_MASK (1<<LC_TIME)
#define LC_COLLATE_MASK (1<<LC_COLLATE)
#define LC_MONETARY_MASK (1<<LC_MONETARY)
#define LC_MESSAGES_MASK (1<<LC_MESSAGES)
#define LC_ALL_MASK 0x7fffffff

locale_t duplocale(locale_t);
void freelocale(locale_t);
locale_t newlocale(int, const char *, locale_t);
locale_t uselocale(locale_t);





}
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/clocale" 2 3


#define _GLIBCXX_CLOCALE 1


#undef setlocale
#undef localeconv

namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/c++locale.h" 2 3

#define _GLIBCXX_NUM_CATEGORIES 0

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


  typedef int* __c_locale;





  inline int
  __convert_from_v(const __c_locale&, char* __out,
     const int __size __attribute__((__unused__)),
     const char* __fmt, ...)
  {
    char* __old = std::setlocale(1, 0);
    char* __sav = 0;
    if (__builtin_strcmp(__old, "C"))
      {
 const size_t __len = __builtin_strlen(__old) + 1;
 __sav = new char[__len];
 __builtin_memcpy(__sav, __old, __len);
 std::setlocale(1, "C");
      }

    __builtin_va_list __args;
    __builtin_va_start(__args, __fmt);


    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);




    __builtin_va_end(__args);

    if (__sav)
      {
 std::setlocale(1, __sav);
 delete [] __sav;
      }
    return __ret;
  }


}
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/localefwd.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/iosfwd" 1 3
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/iosfwd" 3
#define _GLIBCXX_IOSFWD 1
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/iosfwd" 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/iosfwd" 3
  class ios_base;

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

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

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

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

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


namespace __cxx11 {

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

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

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

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

}

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

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

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

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

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

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



  typedef basic_ios<char> ios;


  typedef basic_streambuf<char> streambuf;


  typedef basic_istream<char> istream;


  typedef basic_ostream<char> ostream;


  typedef basic_iostream<char> iostream;


  typedef basic_stringbuf<char> stringbuf;


  typedef basic_istringstream<char> istringstream;


  typedef basic_ostringstream<char> ostringstream;


  typedef basic_stringstream<char> stringstream;


  typedef basic_filebuf<char> filebuf;


  typedef basic_ifstream<char> ifstream;


  typedef basic_ofstream<char> ofstream;


  typedef basic_fstream<char> fstream;



  typedef basic_ios<wchar_t> wios;


  typedef basic_streambuf<wchar_t> wstreambuf;


  typedef basic_istream<wchar_t> wistream;


  typedef basic_ostream<wchar_t> wostream;


  typedef basic_iostream<wchar_t> wiostream;


  typedef basic_stringbuf<wchar_t> wstringbuf;


  typedef basic_istringstream<wchar_t> wistringstream;


  typedef basic_ostringstream<wchar_t> wostringstream;


  typedef basic_stringstream<wchar_t> wstringstream;


  typedef basic_filebuf<wchar_t> wfilebuf;


  typedef basic_ifstream<wchar_t> wifstream;


  typedef basic_ofstream<wchar_t> wofstream;


  typedef basic_fstream<wchar_t> wfstream;




}
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/localefwd.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cctype" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cctype" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/ctype.h" 1 3 4

#define _CTYPE_H 


extern "C" {




int isalnum(int);
int isalpha(int);
int isblank(int);
int iscntrl(int);
int isdigit(int);
int isgraph(int);
int islower(int);
int isprint(int);
int ispunct(int);
int isspace(int);
int isupper(int);
int isxdigit(int);
int tolower(int);
int toupper(int);
# 45 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/ctype.h" 3 4
#define __NEED_locale_t 

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 47 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/ctype.h" 2 3 4

int isalnum_l(int, locale_t);
int isalpha_l(int, locale_t);
int isblank_l(int, locale_t);
int iscntrl_l(int, locale_t);
int isdigit_l(int, locale_t);
int isgraph_l(int, locale_t);
int islower_l(int, locale_t);
int isprint_l(int, locale_t);
int ispunct_l(int, locale_t);
int isspace_l(int, locale_t);
int isupper_l(int, locale_t);
int isxdigit_l(int, locale_t);
int tolower_l(int, locale_t);
int toupper_l(int, locale_t);

int isascii(int);
int toascii(int);
#define _tolower(a) ((a)|0x20)
#define _toupper(a) ((a)&0x5f)
#define isascii(a) (0 ? isascii(a) : (unsigned)(a) < 128)




}
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cctype" 2 3


#define _GLIBCXX_CCTYPE 1


#undef isalnum
#undef isalpha
#undef iscntrl
#undef isdigit
#undef isgraph
#undef islower
#undef isprint
#undef ispunct
#undef isspace
#undef isupper
#undef isxdigit
#undef tolower
#undef toupper

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





#undef isblank

namespace std
{
  using ::isblank;
}
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/localefwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 55 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
}


}
# 44 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/ostream_insert.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/ostream_insert.h" 3
#define _OSTREAM_INSERT_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/ostream_insert.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cxxabi_forced.h" 1 3
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/cxxabi_forced.h" 3
#define _CXXABI_FORCED_H 1
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 3
#define _STL_FUNCTION_H 1





namespace std __attribute__ ((__visibility__ ("default")))
{
# 104 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    };
# 166 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 3
  template<typename _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


  template<typename _Tp>
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };


  template<typename _Tp>
    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
    };


  template<typename _Tp>
    struct divides : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
    };


  template<typename _Tp>
    struct modulus : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
    };


  template<typename _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };
# 350 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 3
  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {

      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>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };


  template<typename _Tp>
    struct greater : public binary_function<_Tp, _Tp, bool>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
    };


  template<typename _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };


  template<typename _Tp>
    struct greater_equal : public binary_function<_Tp, _Tp, bool>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
    };


  template<typename _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };
# 523 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 3
  template<typename _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template<typename _Tp>
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {

      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };


  template<typename _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {

      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };
# 616 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 3
  template<typename _Tp>
    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x & __y; }
    };

  template<typename _Tp>
    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x | __y; }
    };

  template<typename _Tp>
    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
    };

  template<typename _Tp>
    struct bit_not : public unary_function<_Tp, _Tp>
    {

      _Tp
      operator()(const _Tp& __x) const
      { return ~__x; }
    };
# 740 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 3
  template<typename _Predicate>
    class unary_negate
    : public unary_function<typename _Predicate::argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:

      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }


      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }
    };


  template<typename _Predicate>

    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:

      explicit
      binary_negate(const _Predicate& __x) : _M_pred(__x) { }


      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>

    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 817 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 _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; }
    };
# 937 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/backward/binders.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/backward/binders.h" 3
#define _BACKWARD_BINDERS_H 1


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

namespace std __attribute__ ((__visibility__ ("default")))
{
# 107 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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
# 1128 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_function.h" 2 3
# 49 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/range_access.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/range_access.h" 3
#define _GLIBCXX_RANGE_ACCESS_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/range_access.h" 3



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







  template<typename _Container>
    inline auto
    begin(_Container& __cont) -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    inline auto
    begin(const _Container& __cont) -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    inline auto
    end(_Container& __cont) -> decltype(__cont.end())
    { return __cont.end(); }






  template<typename _Container>
    inline auto
    end(const _Container& __cont) -> decltype(__cont.end())
    { return __cont.end(); }





  template<typename _Tp, size_t _Nm>
    inline _Tp*
    begin(_Tp (&__arr)[_Nm])
    { return __arr; }






  template<typename _Tp, size_t _Nm>
    inline _Tp*
    end(_Tp (&__arr)[_Nm])
    { return __arr + _Nm; }
# 320 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/range_access.h" 3
}
# 52 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 1 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
#define _BASIC_STRING_H 1
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/atomicity.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/atomicity.h" 3
#define _GLIBCXX_ATOMICITY_H 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/atomicity.h" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr.h" 1 3
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr.h" 3
#define _GLIBCXX_GCC_GTHR_H 


#pragma GCC visibility push(default)
# 148 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr.h" 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 1 3
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 3
#define _GLIBCXX_GCC_GTHR_POSIX_H 




#define __GTHREADS 1
#define __GTHREADS_CXX0X 1


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/pthread.h" 1 3 4

#define _PTHREAD_H 

extern "C" {




#define __NEED_time_t 
#define __NEED_clockid_t 
#define __NEED_struct_timespec 
#define __NEED_sigset_t 
#define __NEED_pthread_t 
#define __NEED_pthread_attr_t 
#define __NEED_pthread_mutexattr_t 
#define __NEED_pthread_condattr_t 
#define __NEED_pthread_rwlockattr_t 
#define __NEED_pthread_barrierattr_t 
#define __NEED_pthread_mutex_t 
#define __NEED_pthread_cond_t 
#define __NEED_pthread_rwlock_t 
#define __NEED_pthread_barrier_t 
#define __NEED_pthread_spinlock_t 
#define __NEED_pthread_key_t 
#define __NEED_pthread_once_t 
#define __NEED_size_t 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 29 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/pthread.h" 2 3 4

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sched.h" 1 3 4

#define _SCHED_H 

extern "C" {




#define __NEED_struct_timespec 
#define __NEED_pid_t 
#define __NEED_time_t 


#define __NEED_size_t 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 18 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sched.h" 2 3 4

struct sched_param {
 int sched_priority;
 int sched_ss_low_priority;
 struct timespec sched_ss_repl_period;
 struct timespec sched_ss_init_budget;
 int sched_ss_max_repl;
};

int sched_get_priority_max(int);
int sched_get_priority_min(int);
int sched_getparam(pid_t, struct sched_param *);
int sched_getscheduler(pid_t);
int sched_rr_get_interval(pid_t, struct timespec *);
int sched_setparam(pid_t, const struct sched_param *);
int sched_setscheduler(pid_t, int, const struct sched_param *);
int sched_yield(void);

#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2
#define SCHED_BATCH 3
#define SCHED_IDLE 5
#define SCHED_DEADLINE 6
#define SCHED_RESET_ON_FORK 0x40000000


#define CSIGNAL 0x000000ff
#define CLONE_VM 0x00000100
#define CLONE_FS 0x00000200
#define CLONE_FILES 0x00000400
#define CLONE_SIGHAND 0x00000800
#define CLONE_PTRACE 0x00002000
#define CLONE_VFORK 0x00004000
#define CLONE_PARENT 0x00008000
#define CLONE_THREAD 0x00010000
#define CLONE_NEWNS 0x00020000
#define CLONE_SYSVSEM 0x00040000
#define CLONE_SETTLS 0x00080000
#define CLONE_PARENT_SETTID 0x00100000
#define CLONE_CHILD_CLEARTID 0x00200000
#define CLONE_DETACHED 0x00400000
#define CLONE_UNTRACED 0x00800000
#define CLONE_CHILD_SETTID 0x01000000
#define CLONE_NEWCGROUP 0x02000000
#define CLONE_NEWUTS 0x04000000
#define CLONE_NEWIPC 0x08000000
#define CLONE_NEWUSER 0x10000000
#define CLONE_NEWPID 0x20000000
#define CLONE_NEWNET 0x40000000
#define CLONE_IO 0x80000000
int clone (int (*)(void *), void *, int, void *, ...);
int unshare(int);
int setns(int, int);

void *memcpy(void *__restrict, const void *__restrict, size_t);
int memcmp(const void *, const void *, size_t);
void *calloc(size_t, size_t);
void free(void *);

typedef struct cpu_set_t { unsigned long __bits[128/sizeof(long)]; } cpu_set_t;
int __sched_cpucount(size_t, const cpu_set_t *);
int sched_getcpu(void);
int sched_getaffinity(pid_t, size_t, cpu_set_t *);
int sched_setaffinity(pid_t, size_t, const cpu_set_t *);

#define __CPU_op_S(i,size,set,op) ( (i)/8U >= (size) ? 0 : (((unsigned long *)(set))[(i)/8/sizeof(long)] op (1UL<<((i)%(8*sizeof(long))))) )


#define CPU_SET_S(i,size,set) __CPU_op_S(i, size, set, |=)
#define CPU_CLR_S(i,size,set) __CPU_op_S(i, size, set, &=~)
#define CPU_ISSET_S(i,size,set) __CPU_op_S(i, size, set, &)

#define __CPU_op_func_S(func,op) static __inline void __CPU_##func##_S(size_t __size, cpu_set_t *__dest, const cpu_set_t *__src1, const cpu_set_t *__src2) { size_t __i; for (__i=0; __i<__size/sizeof(long); __i++) ((unsigned long *)__dest)[__i] = ((unsigned long *)__src1)[__i] op ((unsigned long *)__src2)[__i] ; }
# 101 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/sched.h" 3 4
static inline void __CPU_AND_S(size_t __size, cpu_set_t *__dest, const cpu_set_t *__src1, const cpu_set_t *__src2) { size_t __i; for (__i=0; __i<__size/sizeof(long); __i++) ((unsigned long *)__dest)[__i] = ((unsigned long *)__src1)[__i] & ((unsigned long *)__src2)[__i] ; }
static inline void __CPU_OR_S(size_t __size, cpu_set_t *__dest, const cpu_set_t *__src1, const cpu_set_t *__src2) { size_t __i; for (__i=0; __i<__size/sizeof(long); __i++) ((unsigned long *)__dest)[__i] = ((unsigned long *)__src1)[__i] | ((unsigned long *)__src2)[__i] ; }
static inline void __CPU_XOR_S(size_t __size, cpu_set_t *__dest, const cpu_set_t *__src1, const cpu_set_t *__src2) { size_t __i; for (__i=0; __i<__size/sizeof(long); __i++) ((unsigned long *)__dest)[__i] = ((unsigned long *)__src1)[__i] ^ ((unsigned long *)__src2)[__i] ; }

#define CPU_AND_S(a,b,c,d) __CPU_AND_S(a,b,c,d)
#define CPU_OR_S(a,b,c,d) __CPU_OR_S(a,b,c,d)
#define CPU_XOR_S(a,b,c,d) __CPU_XOR_S(a,b,c,d)

#define CPU_COUNT_S(size,set) __sched_cpucount(size,set)
#define CPU_ZERO_S(size,set) memset(set,0,size)
#define CPU_EQUAL_S(size,set1,set2) (!memcmp(set1,set2,size))

#define CPU_ALLOC_SIZE(n) (sizeof(long) * ( (n)/(8*sizeof(long)) + ((n)%(8*sizeof(long)) + 8*sizeof(long)-1)/(8*sizeof(long)) ) )

#define CPU_ALLOC(n) ((cpu_set_t *)calloc(1,CPU_ALLOC_SIZE(n)))
#define CPU_FREE(set) free(set)

#define CPU_SETSIZE 128

#define CPU_SET(i,set) CPU_SET_S(i,sizeof(cpu_set_t),set)
#define CPU_CLR(i,set) CPU_CLR_S(i,sizeof(cpu_set_t),set)
#define CPU_ISSET(i,set) CPU_ISSET_S(i,sizeof(cpu_set_t),set)
#define CPU_AND(d,s1,s2) CPU_AND_S(sizeof(cpu_set_t),d,s1,s2)
#define CPU_OR(d,s1,s2) CPU_OR_S(sizeof(cpu_set_t),d,s1,s2)
#define CPU_XOR(d,s1,s2) CPU_XOR_S(sizeof(cpu_set_t),d,s1,s2)
#define CPU_COUNT(set) CPU_COUNT_S(sizeof(cpu_set_t),set)
#define CPU_ZERO(set) CPU_ZERO_S(sizeof(cpu_set_t),set)
#define CPU_EQUAL(s1,s2) CPU_EQUAL_S(sizeof(cpu_set_t),s1,s2)




}
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/pthread.h" 2 3 4
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/time.h" 1 3 4

#define _TIME_H 


extern "C" {





#define NULL 0L





#define __NEED_size_t 
#define __NEED_time_t 
#define __NEED_clock_t 
#define __NEED_struct_timespec 




#define __NEED_clockid_t 
#define __NEED_timer_t 
#define __NEED_pid_t 
#define __NEED_locale_t 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/time.h" 2 3 4


#define __tm_gmtoff tm_gmtoff
#define __tm_zone tm_zone


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 tm_gmtoff;
 const char *tm_zone;
};

clock_t clock (void);
time_t time (time_t *);
double difftime (time_t, time_t);
time_t mktime (struct tm *);
size_t strftime (char *__restrict, size_t, const char *__restrict, const struct tm *__restrict);
struct tm *gmtime (const time_t *);
struct tm *localtime (const time_t *);
char *asctime (const struct tm *);
char *ctime (const time_t *);
int timespec_get(struct timespec *, int);

#define CLOCKS_PER_SEC 1000000L

#define TIME_UTC 1





size_t strftime_l (char * __restrict, size_t, const char * __restrict, const struct tm * __restrict, locale_t);

struct tm *gmtime_r (const time_t *__restrict, struct tm *__restrict);
struct tm *localtime_r (const time_t *__restrict, struct tm *__restrict);
char *asctime_r (const struct tm *__restrict, char *__restrict);
char *ctime_r (const time_t *, char *);

void tzset (void);

struct itimerspec {
 struct timespec it_interval;
 struct timespec it_value;
};

#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 1
#define CLOCK_PROCESS_CPUTIME_ID 2
#define CLOCK_THREAD_CPUTIME_ID 3
#define CLOCK_MONOTONIC_RAW 4
#define CLOCK_REALTIME_COARSE 5
#define CLOCK_MONOTONIC_COARSE 6
#define CLOCK_BOOTTIME 7
#define CLOCK_REALTIME_ALARM 8
#define CLOCK_BOOTTIME_ALARM 9
#define CLOCK_SGI_CYCLE 10
#define CLOCK_TAI 11

#define TIMER_ABSTIME 1

int nanosleep (const struct timespec *, struct timespec *);
int clock_getres (clockid_t, struct timespec *);
int clock_gettime (clockid_t, struct timespec *);
int clock_settime (clockid_t, const struct timespec *);
int clock_nanosleep (clockid_t, int, const struct timespec *, struct timespec *);
int clock_getcpuclockid (pid_t, clockid_t *);

struct sigevent;
int timer_create (clockid_t, struct sigevent *__restrict, timer_t *__restrict);
int timer_delete (timer_t);
int timer_settime (timer_t, int, const struct itimerspec *__restrict, struct itimerspec *__restrict);
int timer_gettime (timer_t, struct itimerspec *);
int timer_getoverrun (timer_t);

extern char *tzname[2];





char *strptime (const char *__restrict, const char *__restrict, struct tm *__restrict);
extern int daylight;
extern long timezone;
extern int getdate_err;
struct tm *getdate (const char *);




int stime(const time_t *);
time_t timegm(struct tm *);



}
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/pthread.h" 2 3 4

#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 1

#define PTHREAD_MUTEX_NORMAL 0
#define PTHREAD_MUTEX_DEFAULT 0
#define PTHREAD_MUTEX_RECURSIVE 1
#define PTHREAD_MUTEX_ERRORCHECK 2

#define PTHREAD_MUTEX_STALLED 0
#define PTHREAD_MUTEX_ROBUST 1

#define PTHREAD_PRIO_NONE 0
#define PTHREAD_PRIO_INHERIT 1
#define PTHREAD_PRIO_PROTECT 2

#define PTHREAD_INHERIT_SCHED 0
#define PTHREAD_EXPLICIT_SCHED 1

#define PTHREAD_SCOPE_SYSTEM 0
#define PTHREAD_SCOPE_PROCESS 1

#define PTHREAD_PROCESS_PRIVATE 0
#define PTHREAD_PROCESS_SHARED 1


#define PTHREAD_MUTEX_INITIALIZER {{{0}}}
#define PTHREAD_RWLOCK_INITIALIZER {{{0}}}
#define PTHREAD_COND_INITIALIZER {{{0}}}
#define PTHREAD_ONCE_INIT 0


#define PTHREAD_CANCEL_ENABLE 0
#define PTHREAD_CANCEL_DISABLE 1
#define PTHREAD_CANCEL_MASKED 2

#define PTHREAD_CANCEL_DEFERRED 0
#define PTHREAD_CANCEL_ASYNCHRONOUS 1

#define PTHREAD_CANCELED ((void *)-1)


#define PTHREAD_BARRIER_SERIAL_THREAD (-1)


int pthread_create(pthread_t *__restrict, const pthread_attr_t *__restrict, void *(*)(void *), void *__restrict);
int pthread_detach(pthread_t);
__attribute__((__noreturn__)) void pthread_exit(void *);
int pthread_join(pthread_t, void **);

pthread_t pthread_self(void);

int pthread_equal(pthread_t, pthread_t);




int pthread_setcancelstate(int, int *);
int pthread_setcanceltype(int, int *);
void pthread_testcancel(void);
int pthread_cancel(pthread_t);

int pthread_getschedparam(pthread_t, int *__restrict, struct sched_param *__restrict);
int pthread_setschedparam(pthread_t, int, const struct sched_param *);
int pthread_setschedprio(pthread_t, int);

int pthread_once(pthread_once_t *, void (*)(void));

int pthread_mutex_init(pthread_mutex_t *__restrict, const pthread_mutexattr_t *__restrict);
int pthread_mutex_lock(pthread_mutex_t *);
int pthread_mutex_unlock(pthread_mutex_t *);
int pthread_mutex_trylock(pthread_mutex_t *);
int pthread_mutex_timedlock(pthread_mutex_t *__restrict, const struct timespec *__restrict);
int pthread_mutex_destroy(pthread_mutex_t *);
int pthread_mutex_consistent(pthread_mutex_t *);

int pthread_mutex_getprioceiling(const pthread_mutex_t *__restrict, int *__restrict);
int pthread_mutex_setprioceiling(pthread_mutex_t *__restrict, int, int *__restrict);

int pthread_cond_init(pthread_cond_t *__restrict, const pthread_condattr_t *__restrict);
int pthread_cond_destroy(pthread_cond_t *);
int pthread_cond_wait(pthread_cond_t *__restrict, pthread_mutex_t *__restrict);
int pthread_cond_timedwait(pthread_cond_t *__restrict, pthread_mutex_t *__restrict, const struct timespec *__restrict);
int pthread_cond_broadcast(pthread_cond_t *);
int pthread_cond_signal(pthread_cond_t *);

int pthread_rwlock_init(pthread_rwlock_t *__restrict, const pthread_rwlockattr_t *__restrict);
int pthread_rwlock_destroy(pthread_rwlock_t *);
int pthread_rwlock_rdlock(pthread_rwlock_t *);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
int pthread_rwlock_timedrdlock(pthread_rwlock_t *__restrict, const struct timespec *__restrict);
int pthread_rwlock_wrlock(pthread_rwlock_t *);
int pthread_rwlock_trywrlock(pthread_rwlock_t *);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *__restrict, const struct timespec *__restrict);
int pthread_rwlock_unlock(pthread_rwlock_t *);

int pthread_spin_init(pthread_spinlock_t *, int);
int pthread_spin_destroy(pthread_spinlock_t *);
int pthread_spin_lock(pthread_spinlock_t *);
int pthread_spin_trylock(pthread_spinlock_t *);
int pthread_spin_unlock(pthread_spinlock_t *);

int pthread_barrier_init(pthread_barrier_t *__restrict, const pthread_barrierattr_t *__restrict, unsigned);
int pthread_barrier_destroy(pthread_barrier_t *);
int pthread_barrier_wait(pthread_barrier_t *);

int pthread_key_create(pthread_key_t *, void (*)(void *));
int pthread_key_delete(pthread_key_t);
void *pthread_getspecific(pthread_key_t);
int pthread_setspecific(pthread_key_t, const void *);

int pthread_attr_init(pthread_attr_t *);
int pthread_attr_destroy(pthread_attr_t *);

int pthread_attr_getguardsize(const pthread_attr_t *__restrict, size_t *__restrict);
int pthread_attr_setguardsize(pthread_attr_t *, size_t);
int pthread_attr_getstacksize(const pthread_attr_t *__restrict, size_t *__restrict);
int pthread_attr_setstacksize(pthread_attr_t *, size_t);
int pthread_attr_getdetachstate(const pthread_attr_t *, int *);
int pthread_attr_setdetachstate(pthread_attr_t *, int);
int pthread_attr_getstack(const pthread_attr_t *__restrict, void **__restrict, size_t *__restrict);
int pthread_attr_setstack(pthread_attr_t *, void *, size_t);
int pthread_attr_getscope(const pthread_attr_t *__restrict, int *__restrict);
int pthread_attr_setscope(pthread_attr_t *, int);
int pthread_attr_getschedpolicy(const pthread_attr_t *__restrict, int *__restrict);
int pthread_attr_setschedpolicy(pthread_attr_t *, int);
int pthread_attr_getschedparam(const pthread_attr_t *__restrict, struct sched_param *__restrict);
int pthread_attr_setschedparam(pthread_attr_t *__restrict, const struct sched_param *__restrict);
int pthread_attr_getinheritsched(const pthread_attr_t *__restrict, int *__restrict);
int pthread_attr_setinheritsched(pthread_attr_t *, int);

int pthread_mutexattr_destroy(pthread_mutexattr_t *);
int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_getrobust(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_gettype(const pthread_mutexattr_t *__restrict, int *__restrict);
int pthread_mutexattr_init(pthread_mutexattr_t *);
int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *, int);
int pthread_mutexattr_setprotocol(pthread_mutexattr_t *, int);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *, int);
int pthread_mutexattr_setrobust(pthread_mutexattr_t *, int);
int pthread_mutexattr_settype(pthread_mutexattr_t *, int);

int pthread_condattr_init(pthread_condattr_t *);
int pthread_condattr_destroy(pthread_condattr_t *);
int pthread_condattr_setclock(pthread_condattr_t *, clockid_t);
int pthread_condattr_setpshared(pthread_condattr_t *, int);
int pthread_condattr_getclock(const pthread_condattr_t *__restrict, clockid_t *__restrict);
int pthread_condattr_getpshared(const pthread_condattr_t *__restrict, int *__restrict);

int pthread_rwlockattr_init(pthread_rwlockattr_t *);
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *);
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *, int);
int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *__restrict, int *__restrict);

int pthread_barrierattr_destroy(pthread_barrierattr_t *);
int pthread_barrierattr_getpshared(const pthread_barrierattr_t *__restrict, int *__restrict);
int pthread_barrierattr_init(pthread_barrierattr_t *);
int pthread_barrierattr_setpshared(pthread_barrierattr_t *, int);

int pthread_atfork(void (*)(void), void (*)(void), void (*)(void));

int pthread_getconcurrency(void);
int pthread_setconcurrency(int);

int pthread_getcpuclockid(pthread_t, clockid_t *);

struct __ptcb {
 void (*__f)(void *);
 void *__x;
 struct __ptcb *__next;
};

void _pthread_cleanup_push(struct __ptcb *, void (*)(void *), void *);
void _pthread_cleanup_pop(struct __ptcb *, int);

#define pthread_cleanup_push(f,x) do { struct __ptcb __cb; _pthread_cleanup_push(&__cb, f, x);
#define pthread_cleanup_pop(r) _pthread_cleanup_pop(&__cb, (r)); } while(0)


struct cpu_set_t;
int pthread_getaffinity_np(pthread_t, size_t, struct cpu_set_t *);
int pthread_setaffinity_np(pthread_t, size_t, const struct cpu_set_t *);
int pthread_getattr_np(pthread_t, pthread_attr_t *);
int pthread_setname_np(pthread_t, const char *);
int pthread_getattr_default_np(pthread_attr_t *);
int pthread_setattr_default_np(const pthread_attr_t *);
int pthread_tryjoin_np(pthread_t, void **);
int pthread_timedjoin_np(pthread_t, void **, const struct timespec *);



}
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 2 3
# 47 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/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;



#define __GTHREAD_HAS_COND 1

#define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
#define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT





#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function

#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
#define __GTHREAD_TIME_INIT {0,0}
# 94 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 3
#define __gthrw2(name,name2,type) 
#define __gthrw_(name) name



#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
# 298 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  return 1;
}
# 658 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
    void *__args)
{
  return pthread_create (__threadid, 0L, __func, __args);
}

static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
  return pthread_join (__threadid, __value_ptr);
}

static inline int
__gthread_detach (__gthread_t __threadid)
{
  return pthread_detach (__threadid);
}

static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  return pthread_equal (__t1, __t2);
}

static inline __gthread_t
__gthread_self (void)
{
  return pthread_self ();
}

static inline int
__gthread_yield (void)
{
  return sched_yield ();
}

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return pthread_once (__once, __func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return pthread_key_create (__key, __dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t __key)
{
  return pthread_key_delete (__key);
}

static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  return pthread_getspecific (__key);
}

static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  return pthread_setspecific (__key, __ptr);
}

static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    pthread_mutex_init (__mutex, 0L);
}

static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_destroy (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_trylock (__mutex);
  else
    return 0;
}


static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
      const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return pthread_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}


static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_unlock (__mutex);
  else
    return 0;
}



static inline int
__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      pthread_mutexattr_t __attr;
      int __r;

      __r = pthread_mutexattr_init (&__attr);
      if (!__r)
 __r = pthread_mutexattr_settype (&__attr,
         1);
      if (!__r)
 __r = pthread_mutex_init (__mutex, &__attr);
      if (!__r)
 __r = pthread_mutexattr_destroy (&__attr);
      return __r;
    }
  return 0;
}


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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr-default.h" 3
static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  return pthread_cond_broadcast (__cond);
}

static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  return pthread_cond_signal (__cond);
}

static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  return pthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
     const __gthread_time_t *__abs_timeout)
{
  return pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}

static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
          __gthread_recursive_mutex_t *__mutex)
{
  return __gthread_cond_wait (__cond, __mutex);
}

static inline int
__gthread_cond_destroy (__gthread_cond_t* __cond)
{
  return pthread_cond_destroy (__cond);
}
# 149 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/gthr.h" 2 3


#pragma GCC visibility pop
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/atomicity.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/atomic_word.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/aarch64-bec-linux-musl/bits/atomic_word.h" 3
#define _GLIBCXX_ATOMIC_WORD_H 1

typedef int _Atomic_word;



#define _GLIBCXX_READ_MEM_BARRIER __atomic_thread_fence (__ATOMIC_ACQUIRE)

#define _GLIBCXX_WRITE_MEM_BARRIER __atomic_thread_fence (__ATOMIC_RELEASE)
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/alloc_traits.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/alloc_traits.h" 3
#define _EXT_ALLOC_TRAITS_H 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/alloc_traits.h" 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
#define _ALLOC_TRAITS_H 1







#define __cpp_lib_allocator_traits_is_always_equal 201411

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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      static pointer
      allocate(_Alloc& __a, size_type __n)
      { return __a.allocate(__n); }
# 314 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      static void
      deallocate(_Alloc& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 341 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      template<typename _Tp>
 static void destroy(_Alloc& __a, _Tp* __p)
 { _S_destroy(__a, __p, 0); }
# 366 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      static size_type max_size(const _Alloc& __a) noexcept
      { return _S_max_size(__a, 0); }
# 377 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      static pointer
      allocate(allocator_type& __a, size_type __n)
      { return __a.allocate(__n); }
# 448 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      static pointer
      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
      { return __a.allocate(__n, __hint); }
# 460 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/alloc_traits.h" 3
      static void
      deallocate(allocator_type& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 472 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>
    { };


}
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/alloc_traits.h" 2 3




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






template<typename _Alloc>
  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::addressof(*__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::addressof(*__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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/alloc_traits.h" 3
  };


}
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 2 3
# 52 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



namespace __cxx11 {
# 76 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 123 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      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:
# 282 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 434 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 465 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 483 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 515 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
      }
# 583 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 619 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      ~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); }
# 676 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 694 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 779 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      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; }
# 908 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 921 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 970 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 999 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const noexcept
      {
                                  ;
 return _M_data()[__pos];
      }
# 1016 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {


                                  ;

                                                                   ;
 return _M_data()[__pos];
      }
# 1037 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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];
      }
# 1058 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1121 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1173 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str)
      { return _M_append(__str._M_data(), __str.size()); }
# 1190 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1232 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1256 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1297 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      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;
      }
# 1328 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      basic_string&
      assign(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {


 return *this = std::move(__str);
      }
# 1351 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)); }
# 1367 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n)
      {
                                        ;
 return _M_replace(size_type(0), this->size(), __s, __n);
      }
# 1383 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
                               ;
 return _M_replace(size_type(0), this->size(), __s,
     traits_type::length(__s));
      }
# 1400 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1413 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1477 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1519 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
 }
# 1555 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      void
      insert(iterator __p, initializer_list<_CharT> __l)
      {
                                                         ;
 this->insert(__p - begin(), __l.begin(), __l.size());
      }
# 1575 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1598 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)); }
# 1621 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1640 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 1664 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1682 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1738 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 1757 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1776 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1820 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1842 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)); }
# 1867 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1892 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 1916 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1934 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1954 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 1976 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 1997 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 2022 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
 }
# 2054 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
      }
# 2113 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2164 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
    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:
# 2202 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 2212 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      void
      swap(basic_string& __s) noexcept;
# 2222 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      const _CharT*
      c_str() const noexcept
      { return _M_data(); }
# 2234 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      const _CharT*
      data() const noexcept
      { return _M_data(); }
# 2253 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      allocator_type
      get_allocator() const noexcept
      { return _M_get_allocator(); }
# 2269 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2283 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2310 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 2327 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;
# 2340 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2369 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2383 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 2400 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 2414 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2443 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2457 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 2477 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }
# 2492 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2521 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2535 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 2555 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
      { return this->rfind(__c, __pos); }
# 2569 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2598 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const noexcept;
# 2612 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 2630 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const
      noexcept;
# 2645 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 2674 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const noexcept;
# 2688 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
      }
# 2706 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const
      noexcept;
# 2722 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 2741 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 2823 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2849 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2) const;
# 2867 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const noexcept;
# 2891 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2918 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const;
  };
}
# 5684 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)); }
# 5805 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 5852 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 5890 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 5928 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 5966 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 6004 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 6042 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 6062 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
# 6080 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 6103 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
# 6120 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/string_conversions.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/string_conversions.h" 3
#define _STRING_CONVERSIONS_H 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/string_conversions.h" 3








# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 3




#define _GLIBCXX_CSTDLIB 1
# 74 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 3
#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdlib.h" 1 3 4

#define _STDLIB_H 


extern "C" {





#define NULL 0L




#define __NEED_size_t 
#define __NEED_wchar_t 


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 20 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdlib.h" 2 3 4

int atoi (const char *);
long atol (const char *);
long long atoll (const char *);
double atof (const char *);

float strtof (const char *__restrict, char **__restrict);
double strtod (const char *__restrict, char **__restrict);
long double strtold (const char *__restrict, char **__restrict);

long strtol (const char *__restrict, char **__restrict, int);
unsigned long strtoul (const char *__restrict, char **__restrict, int);
long long strtoll (const char *__restrict, char **__restrict, int);
unsigned long long strtoull (const char *__restrict, char **__restrict, int);

int rand (void);
void srand (unsigned);

void *malloc (size_t);
void *calloc (size_t, size_t);
void *realloc (void *, size_t);
void free (void *);
void *aligned_alloc(size_t, size_t);

__attribute__((__noreturn__)) void abort (void);
int atexit (void (*) (void));
__attribute__((__noreturn__)) void exit (int);
__attribute__((__noreturn__)) void _Exit (int);
int at_quick_exit (void (*) (void));
__attribute__((__noreturn__)) void quick_exit (int);

char *getenv (const char *);

int system (const char *);

void *bsearch (const void *, const void *, size_t, size_t, int (*)(const void *, const void *));
void qsort (void *, size_t, size_t, int (*)(const void *, const void *));

int abs (int);
long labs (long);
long long llabs (long long);

typedef struct { int quot, rem; } div_t;
typedef struct { long quot, rem; } ldiv_t;
typedef struct { long long quot, rem; } lldiv_t;

div_t div (int, int);
ldiv_t ldiv (long, long);
lldiv_t lldiv (long long, long long);

int mblen (const char *, size_t);
int mbtowc (wchar_t *__restrict, const char *__restrict, size_t);
int wctomb (char *, wchar_t);
size_t mbstowcs (wchar_t *__restrict, const char *__restrict, size_t);
size_t wcstombs (char *__restrict, const wchar_t *__restrict, size_t);

#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0

size_t __ctype_get_mb_cur_max(void);
#define MB_CUR_MAX (__ctype_get_mb_cur_max())

#define RAND_MAX (0x7fffffff)






#define WNOHANG 1
#define WUNTRACED 2

#define WEXITSTATUS(s) (((s) & 0xff00) >> 8)
#define WTERMSIG(s) ((s) & 0x7f)
#define WSTOPSIG(s) WEXITSTATUS(s)
#define WIFEXITED(s) (!WTERMSIG(s))
#define WIFSTOPPED(s) ((short)((((s)&0xffff)*0x10001)>>8) > 0x7f00)
#define WIFSIGNALED(s) (((s)&0xffff)-1U < 0xffu)

int posix_memalign (void **, size_t, size_t);
int setenv (const char *, const char *, int);
int unsetenv (const char *);
int mkstemp (char *);
int mkostemp (char *, int);
char *mkdtemp (char *);
int getsubopt (char **, char *const *, char **);
int rand_r (unsigned *);






char *realpath (const char *__restrict, char *__restrict);
long int random (void);
void srandom (unsigned int);
char *initstate (unsigned int, char *, size_t);
char *setstate (char *);
int putenv (char *);
int posix_openpt (int);
int grantpt (int);
int unlockpt (int);
char *ptsname (int);
char *l64a (long);
long a64l (const char *);
void setkey (const char *);
double drand48 (void);
double erand48 (unsigned short [3]);
long int lrand48 (void);
long int nrand48 (unsigned short [3]);
long mrand48 (void);
long jrand48 (unsigned short [3]);
void srand48 (long);
unsigned short *seed48 (unsigned short [3]);
void lcong48 (unsigned short [7]);




# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/alloca.h" 1 3 4

#define _ALLOCA_H 


extern "C" {


#define __NEED_size_t 

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 10 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/alloca.h" 2 3 4

void *alloca(size_t);


#define alloca __builtin_alloca



}
# 139 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdlib.h" 2 3 4
char *mktemp (char *);
int mkstemps (char *, int);
int mkostemps (char *, int, int);
void *valloc (size_t);
void *memalign(size_t, size_t);
int getloadavg(double *, int);
int clearenv(void);
#define WCOREDUMP(s) ((s) & 0x80)
#define WIFCONTINUED(s) ((s) == 0xffff)



int ptsname_r(int, char *, size_t);
char *ecvt(double, int, int *, int *);
char *fcvt(double, int, int *, int *);
char *gcvt(double, int, char *);
struct __locale_struct;
float strtof_l(const char *__restrict, char **__restrict, struct __locale_struct *);
double strtod_l(const char *__restrict, char **__restrict, struct __locale_struct *);
long double strtold_l(const char *__restrict, char **__restrict, struct __locale_struct *);



#define mkstemp64 mkstemp
#define mkostemp64 mkostemp

#define mkstemps64 mkstemps
#define mkostemps64 mkostemps




}
# 76 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 2 3
#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/std_abs.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/std_abs.h" 3
#define _GLIBCXX_BITS_STD_ABS_H 
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/std_abs.h" 3



#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 




#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS

#undef abs

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); }



  inline constexpr __int128
  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 107 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/std_abs.h" 3
}
}
# 78 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 2 3


#undef abort
#undef atexit


#undef at_quick_exit


#undef atof
#undef atoi
#undef atol
#undef bsearch
#undef calloc
#undef div
#undef exit
#undef free
#undef getenv
#undef labs
#undef ldiv
#undef malloc
#undef mblen
#undef mbstowcs
#undef mbtowc
#undef qsort


#undef quick_exit


#undef rand
#undef realloc
#undef srand
#undef strtod
#undef strtol
#undef strtoul
#undef system
#undef wcstombs
#undef wctomb

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


  using ::div_t;
  using ::ldiv_t;

  using ::abort;
  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); }




}



#undef _Exit
#undef llabs
#undef lldiv
#undef atoll
#undef strtoll
#undef strtoull
#undef strtof
#undef strtold

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;
# 221 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/string_conversions.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cwchar" 3
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/string_conversions.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdio" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdio" 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdio.h" 1 3 4

#define _STDIO_H 


extern "C" {




#define __NEED_FILE 
#define __NEED___isoc_va_list 
#define __NEED_size_t 




#define __NEED_ssize_t 
#define __NEED_off_t 
#define __NEED_va_list 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 1 3 4
#define _Addr long
#define _Int64 long
#define _Reg long
# 399 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/bits/alltypes.h" 3 4
#undef _Addr
#undef _Int64
#undef _Reg
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/include/stdio.h" 2 3 4


#define NULL 0L




#undef EOF
#define EOF (-1)

#undef SEEK_SET
#undef SEEK_CUR
#undef SEEK_END
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2

#define _IOFBF 0
#define _IOLBF 1
#define _IONBF 2

#define BUFSIZ 1024
#define FILENAME_MAX 4096
#define FOPEN_MAX 1000
#define TMP_MAX 10000
#define L_tmpnam 20

typedef union _G_fpos64_t {
 char __opaque[16];
 double __align;
} fpos_t;

extern FILE *const stdin;
extern FILE *const stdout;
extern FILE *const stderr;

#define stdin (stdin)
#define stdout (stdout)
#define stderr (stderr)

FILE *fopen(const char *__restrict, const char *__restrict);
FILE *freopen(const char *__restrict, const char *__restrict, FILE *__restrict);
int fclose(FILE *);

int remove(const char *);
int rename(const char *, const char *);

int feof(FILE *);
int ferror(FILE *);
int fflush(FILE *);
void clearerr(FILE *);

int fseek(FILE *, long, int);
long ftell(FILE *);
void rewind(FILE *);

int fgetpos(FILE *__restrict, fpos_t *__restrict);
int fsetpos(FILE *, const fpos_t *);

size_t fread(void *__restrict, size_t, size_t, FILE *__restrict);
size_t fwrite(const void *__restrict, size_t, size_t, FILE *__restrict);

int fgetc(FILE *);
int getc(FILE *);
int getchar(void);
int ungetc(int, FILE *);

int fputc(int, FILE *);
int putc(int, FILE *);
int putchar(int);

char *fgets(char *__restrict, int, FILE *__restrict);

char *gets(char *);


int fputs(const char *__restrict, FILE *__restrict);
int puts(const char *);

int printf(const char *__restrict, ...);
int fprintf(FILE *__restrict, const char *__restrict, ...);
int sprintf(char *__restrict, const char *__restrict, ...);
int snprintf(char *__restrict, size_t, const char *__restrict, ...);

int vprintf(const char *__restrict, __isoc_va_list);
int vfprintf(FILE *__restrict, const char *__restrict, __isoc_va_list);
int vsprintf(char *__restrict, const char *__restrict, __isoc_va_list);
int vsnprintf(char *__restrict, size_t, const char *__restrict, __isoc_va_list);

int scanf(const char *__restrict, ...);
int fscanf(FILE *__restrict, const char *__restrict, ...);
int sscanf(const char *__restrict, const char *__restrict, ...);
int vscanf(const char *__restrict, __isoc_va_list);
int vfscanf(FILE *__restrict, const char *__restrict, __isoc_va_list);
int vsscanf(const char *__restrict, const char *__restrict, __isoc_va_list);

void perror(const char *);

int setvbuf(FILE *__restrict, char *__restrict, int, size_t);
void setbuf(FILE *__restrict, char *__restrict);

char *tmpnam(char *);
FILE *tmpfile(void);




FILE *fmemopen(void *__restrict, size_t, const char *__restrict);
FILE *open_memstream(char **, size_t *);
FILE *fdopen(int, const char *);
FILE *popen(const char *, const char *);
int pclose(FILE *);
int fileno(FILE *);
int fseeko(FILE *, off_t, int);
off_t ftello(FILE *);
int dprintf(int, const char *__restrict, ...);
int vdprintf(int, const char *__restrict, __isoc_va_list);
void flockfile(FILE *);
int ftrylockfile(FILE *);
void funlockfile(FILE *);
int getc_unlocked(FILE *);
int getchar_unlocked(void);
int putc_unlocked(int, FILE *);
int putchar_unlocked(int);
ssize_t getdelim(char **__restrict, size_t *__restrict, int, FILE *__restrict);
ssize_t getline(char **__restrict, size_t *__restrict, FILE *__restrict);
int renameat(int, const char *, int, const char *);
char *ctermid(char *);
#define L_ctermid 20





#define P_tmpdir "/tmp"
char *tempnam(const char *, const char *);



#define L_cuserid 20
char *cuserid(char *);
void setlinebuf(FILE *);
void setbuffer(FILE *, char *, size_t);
int fgetc_unlocked(FILE *);
int fputc_unlocked(int, FILE *);
int fflush_unlocked(FILE *);
size_t fread_unlocked(void *, size_t, size_t, FILE *);
size_t fwrite_unlocked(const void *, size_t, size_t, FILE *);
void clearerr_unlocked(FILE *);
int feof_unlocked(FILE *);
int ferror_unlocked(FILE *);
int fileno_unlocked(FILE *);
int getw(FILE *);
int putw(int, FILE *);
char *fgetln(FILE *, size_t *);
int asprintf(char **, const char *, ...);
int vasprintf(char **, const char *, __isoc_va_list);



char *fgets_unlocked(char *, int, FILE *);
int fputs_unlocked(const char *, FILE *);



#define tmpfile64 tmpfile
#define fopen64 fopen
#define freopen64 freopen
#define fseeko64 fseeko
#define ftello64 ftello
#define fgetpos64 fgetpos
#define fsetpos64 fsetpos
#define fpos64_t fpos_t
#define off64_t off_t



}
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdio" 2 3


#define _GLIBCXX_CSTDIO 1






#undef clearerr
#undef fclose
#undef feof
#undef ferror
#undef fflush
#undef fgetc
#undef fgetpos
#undef fgets
#undef fopen
#undef fprintf
#undef fputc
#undef fputs
#undef fread
#undef freopen
#undef fscanf
#undef fseek
#undef fsetpos
#undef ftell
#undef fwrite
#undef getc
#undef getchar

#undef gets

#undef perror
#undef printf
#undef putc
#undef putchar
#undef puts
#undef remove
#undef rename
#undef rewind
#undef scanf
#undef setbuf
#undef setvbuf
#undef sprintf
#undef sscanf
#undef tmpfile
#undef tmpnam
#undef ungetc
#undef vfprintf
#undef vprintf
#undef vsprintf

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 ::gets;

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



#undef snprintf
#undef vfscanf
#undef vscanf
#undef vsnprintf
#undef vsscanf

namespace __gnu_cxx
{
# 175 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/string_conversions.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cerrno" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cerrno" 3





#define _GLIBCXX_CERRNO 1
# 45 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
    }


}
# 6160 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
  }



}

}






# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functional_hash.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functional_hash.h" 3
#define _FUNCTIONAL_HASH_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functional_hash.h" 3



namespace std __attribute__ ((__visibility__ ("default")))
{
# 49 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functional_hash.h" 3
  template<typename _Result, typename _Arg>
    struct __hash_base
    {
      typedef _Result result_type;
      typedef _Arg argument_type;
    };


  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); }
    };


#define _Cxx_hashtable_define_trivial_hash(_Tp) template<> struct hash<_Tp> : public __hash_base<size_t, _Tp> { size_t operator()(_Tp __val) const noexcept { return static_cast<size_t>(__val); } };
# 124 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); } };


  template<> struct hash<__int128> : public __hash_base<size_t, __int128> { size_t operator()(__int128 __val) const noexcept { return static_cast<size_t>(__val); } };
  template<> struct hash<__int128 unsigned> : public __hash_base<size_t, __int128 unsigned> { size_t operator()(__int128 unsigned __val) const noexcept { return static_cast<size_t>(__val); } };
# 185 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/functional_hash.h" 3
#undef _Cxx_hashtable_define_trivial_hash

 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
    { };


}
# 6386 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 2 3

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
    { };
# 6500 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.h" 3
}
# 53 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.tcc" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/basic_string.tcc" 3
#define _BASIC_STRING_TCC 1
# 43 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }




  extern template class basic_string<char>;
  extern template
    basic_istream<char>&
    operator>>(basic_istream<char>&, string&);
  extern template
    basic_ostream<char>&
    operator<<(basic_ostream<char>&, const string&);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&, char);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&);


  extern template class basic_string<wchar_t>;
  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);




}
# 54 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/string" 2 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/stdexcept" 2 3

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





  struct __cow_string
  {
    union {
      const char* _M_p;
      char _M_bytes[sizeof(const char*)];
    };

    __cow_string();
    __cow_string(const std::string&);
    __cow_string(const char*, size_t);
    __cow_string(const __cow_string&) noexcept;
    __cow_string& operator=(const __cow_string&) noexcept;
    ~__cow_string();

    __cow_string(__cow_string&&) noexcept;
    __cow_string& operator=(__cow_string&&) noexcept;

  };

  typedef basic_string<char> __sso_string;
# 113 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
  };




}
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/array" 2 3



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


  template<typename _Tp, std::size_t _Nm>
    struct __array_traits
    {
      typedef _Tp _Type[_Nm];
      typedef __is_swappable<_Tp> _Is_swappable;
      typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;

      static constexpr _Tp&
      _S_ref(const _Type& __t, std::size_t __n) noexcept
      { return const_cast<_Tp&>(__t[__n]); }

      static constexpr _Tp*
      _S_ptr(const _Type& __t) noexcept
      { return const_cast<_Tp*>(__t); }
    };

 template<typename _Tp>
   struct __array_traits<_Tp, 0>
   {
     struct _Type { };
     typedef true_type _Is_swappable;
     typedef true_type _Is_nothrow_swappable;

     static constexpr _Tp&
     _S_ref(const _Type&, std::size_t) noexcept
     { return *static_cast<_Tp*>(nullptr); }

     static constexpr _Tp*
     _S_ptr(const _Type&) noexcept
     { return nullptr; }
   };
# 93 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }


                           iterator
      begin() noexcept
      { return iterator(data()); }

                           const_iterator
      begin() const noexcept
      { return const_iterator(data()); }

                           iterator
      end() noexcept
      { return iterator(data() + _Nm); }

                           const_iterator
      end() const noexcept
      { return const_iterator(data() + _Nm); }

                           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(data()); }

                           const_iterator
      cend() const noexcept
      { return const_iterator(data() + _Nm); }

                           const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

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


                           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); }

                           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));
      }

                           reference
      front() noexcept
      { return *begin(); }

      constexpr const_reference
      front() const noexcept
      { return _AT_Type::_S_ref(_M_elems, 0); }

                           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);
      }

                           pointer
      data() noexcept
      { return _AT_Type::_S_ptr(_M_elems); }

                           const_pointer
      data() const noexcept
      { return _AT_Type::_S_ptr(_M_elems); }
    };
# 250 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/array" 3
  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);
    }


}

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





  template<typename _Tp>
    class 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>
    class 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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uses_allocator.h" 1 3
# 26 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uses_allocator.h" 3
#define _USES_ALLOCATOR_H 1








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

                    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<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>
    struct __is_nothrow_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_nothrow_constructible,
        _Tp, _Alloc, _Args...>
    { };
# 156 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uses_allocator.h" 3
  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)...);
    }


}
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/invoke.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/invoke.h" 3
#define _GLIBCXX_INVOKE_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/invoke.h" 3







namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
    };
# 889 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 3
  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)> { };
# 1278 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 3
  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));
    }
# 1366 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 3
  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>
                           const _Swallow_assign&
      operator=(const _Tp&) const
      { return *this; }
  };



                    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))...)
      { }
# 1696 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/tuple" 3
}
# 42 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 2 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/aligned_buffer.h" 1 3
# 30 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/ext/aligned_buffer.h" 3
#define _ALIGNED_BUFFER_H 1
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
    };






  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()); }
    };

}
# 45 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 2 3


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable.h" 3
#define _HASHTABLE_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable.h" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable_policy.h" 1 3
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable_policy.h" 3
#define _HASHTABLE_POLICY_H 1



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 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)
    {
      typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag;
      return __distance_fw(__first, __last, _Tag());
    }


  template <typename _Key, typename _Hash>
    struct __is_noexcept_hash : std::__bool_constant<
 noexcept(declval<const _Hash&>()(declval<const _Key&>()))>
    { };

  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 __value_alloc_type = typename __hashtable_alloc::__value_alloc_type;
      using __value_alloc_traits =
 typename __hashtable_alloc::__value_alloc_traits;
      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;
       __value_alloc_type __a(_M_h._M_node_allocator());
       __value_alloc_traits::destroy(__a, __node->_M_valptr());
       try
  {
    __value_alloc_traits::construct(__a, __node->_M_valptr(),
        std::forward<_Arg>(__arg));
  }
       catch(...)
  {
    __node->~__node_type();
    __node_alloc_traits::deallocate(_M_h._M_node_allocator(),
        __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;
    };
# 213 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>;
    };
# 229 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
  };



  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;
  };
# 652 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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&);

    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);
 }
    };

  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)
      {
 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);

 __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;
# 1157 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
    };
# 1750 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 1899 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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_type = typename __node_type::value_type;
      using __value_alloc_type =
 __alloc_rebind<__node_alloc_type, __value_type>;
      using __value_alloc_traits = std::allocator_traits<__value_alloc_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::__addressof(*__nptr);
 try
   {
     __value_alloc_type __a(_M_node_allocator());
     ::new ((void*)__n) __node_type;
     __value_alloc_traits::construct(__a, __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);
      __value_alloc_type __a(_M_node_allocator());
      __value_alloc_traits::destroy(__a, __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::__addressof(*__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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable.h" 2 3




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


  template<typename _Tp, typename _Hash>
    using __cache_default
      = __not_<__and_<
         __is_fast_hash<_Hash>,

         __detail::__is_noexcept_hash<_Tp, _Hash>>>;
# 169 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>>>
    {
      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;






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



      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&, std::true_type);

      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
    std::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, std::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&, std::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);
# 902 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/hashtable.h" 3
    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;
   }

 try
   {
     for (; __f != __l; ++__f)
       this->insert(*__f);
   }
 catch(...)
   {
     clear();
     _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>
    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)
    -> 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);
       __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, std::true_type)
      -> 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 std::make_pair(_M_insert_unique_node(__bkt, __code, __n), 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, std::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;
    }






}
# 48 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
#define _UNORDERED_MAP_H 

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;
# 97 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
  template<class _Key, class _Tp,
    class _Hash = hash<_Key>,
    class _Pred = std::equal_to<_Key>,
    class _Alloc = std::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;
# 140 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      unordered_map() = default;
# 149 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
      { }
# 170 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
      { }
# 225 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 287 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }
# 384 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 415 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)...); }
# 577 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_h.insert(__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)); }
# 611 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __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)); }
# 632 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 644 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 781 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 803 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 821 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }
# 845 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      void
      swap(unordered_map& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }
# 885 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      hasher
      hash_function() const
      { return _M_h.hash_function(); }



      key_equal
      key_eq() const
      { return _M_h.key_eq(); }
# 909 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 927 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }
# 940 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 962 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)]; }
# 979 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1035 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1050 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1061 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1098 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1109 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>&);
    };
# 1143 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
  template<class _Key, class _Tp,
    class _Hash = hash<_Key>,
    class _Pred = std::equal_to<_Key>,
    class _Alloc = std::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;
# 1185 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      unordered_multimap() = default;
# 1194 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
      { }
# 1215 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
      { }
# 1270 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 1332 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }
# 1424 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1451 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)...); }
# 1466 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_h.insert(__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)); }
# 1498 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __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)); }
# 1519 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1532 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 1575 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1596 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1615 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }
# 1639 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      void
      swap(unordered_multimap& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }
# 1681 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      hasher
      hash_function() const
      { return _M_h.hash_function(); }



      key_equal
      key_eq() const
      { return _M_h.key_eq(); }
# 1705 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1730 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1786 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1801 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1812 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1849 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1860 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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<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); }
# 1965 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/unordered_map.h" 3
}
# 49 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/unordered_map" 2 3
# 35 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 1
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h"
#define KJ_MAIN_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3





# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/function.h" 1 3
# 23 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/function.h" 3
#define KJ_FUNCTION_H_ 
# 27 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/function.h" 3




namespace kj {

template <typename Signature>
class Function;
# 89 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/function.h" 3
template <typename Signature>
class ConstFunction;


template <typename Return, typename... Params>
class Function<Return(Params...)> {
public:
  template <typename F>
  inline Function(F&& f): impl(heap<Impl<F>>(kj::fwd<F>(f))) {}
  Function() = default;



  Function(const Function&) = delete; Function& operator=(const Function&) = delete;
  Function(Function&) = delete;
  Function& operator=(Function&) = delete;
  template <typename T> Function(const Function<T>&) = delete;
  template <typename T> Function& operator=(const Function<T>&) = delete;
  template <typename T> Function(const ConstFunction<T>&) = delete;
  template <typename T> Function& operator=(const ConstFunction<T>&) = delete;
  Function(Function&&) = default;
  Function& operator=(Function&&) = default;

  inline Return operator()(Params... params) {
    return (*impl)(kj::fwd<Params>(params)...);
  }

  Function reference() {




    return *impl;
  }

private:
  class Iface {
  public:
    virtual Return operator()(Params... params) = 0;
  };

  template <typename F>
  class Impl final: public Iface {
  public:
    explicit Impl(F&& f): f(kj::fwd<F>(f)) {}

    Return operator()(Params... params) override {
      return f(kj::fwd<Params>(params)...);
    }

  private:
    F f;
  };

  Own<Iface> impl;
};

template <typename Return, typename... Params>
class ConstFunction<Return(Params...)> {
public:
  template <typename F>
  inline ConstFunction(F&& f): impl(heap<Impl<F>>(kj::fwd<F>(f))) {}
  ConstFunction() = default;



  ConstFunction(const ConstFunction&) = delete; ConstFunction& operator=(const ConstFunction&) = delete;
  ConstFunction(ConstFunction&) = delete;
  ConstFunction& operator=(ConstFunction&) = delete;
  template <typename T> ConstFunction(const ConstFunction<T>&) = delete;
  template <typename T> ConstFunction& operator=(const ConstFunction<T>&) = delete;
  template <typename T> ConstFunction(const Function<T>&) = delete;
  template <typename T> ConstFunction& operator=(const Function<T>&) = delete;
  ConstFunction(ConstFunction&&) = default;
  ConstFunction& operator=(ConstFunction&&) = default;

  inline Return operator()(Params... params) const {
    return (*impl)(kj::fwd<Params>(params)...);
  }

  ConstFunction reference() const {




    return *impl;
  }

private:
  class Iface {
  public:
    virtual Return operator()(Params... params) const = 0;
  };

  template <typename F>
  class Impl final: public Iface {
  public:
    explicit Impl(F&& f): f(kj::fwd<F>(f)) {}

    Return operator()(Params... params) const override {
      return f(kj::fwd<Params>(params)...);
    }

  private:
    F f;
  };

  Own<Iface> impl;
};



namespace _ {

template <typename T, typename Signature, Signature method>
class BoundMethod;

template <typename T, typename Return, typename... Params, Return (Decay<T>::*method)(Params...)>
class BoundMethod<T, Return (Decay<T>::*)(Params...), method> {
public:
  BoundMethod(T&& t): t(kj::fwd<T>(t)) {}

  Return operator()(Params&&... params) {
    return (t.*method)(kj::fwd<Params>(params)...);
  }

private:
  T t;
};

template <typename T, typename Return, typename... Params,
          Return (Decay<T>::*method)(Params...) const>
class BoundMethod<T, Return (Decay<T>::*)(Params...) const, method> {
public:
  BoundMethod(T&& t): t(kj::fwd<T>(t)) {}

  Return operator()(Params&&... params) const {
    return (t.*method)(kj::fwd<Params>(params)...);
  }

private:
  T t;
};

}

#define KJ_BIND_METHOD(obj,method) ::kj::_::BoundMethod<KJ_DECLTYPE_REF(obj), decltype(&::kj::Decay<decltype(obj)>::method), &::kj::Decay<decltype(obj)>::method>(obj)
# 275 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/function.h" 3
}
# 33 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 2 3

namespace kj {

class ProcessContext {


public:
  virtual StringPtr getProgramName() = 0;


  virtual void exit() __attribute__((noreturn)) = 0;
# 109 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
  virtual void warning(StringPtr message) = 0;



  virtual void error(StringPtr message) = 0;



  virtual void exitError(StringPtr message) __attribute__((noreturn)) = 0;


  virtual void exitInfo(StringPtr message) __attribute__((noreturn)) = 0;



  virtual void increaseLoggingVerbosity() = 0;





};

class TopLevelProcessContext final: public ProcessContext {





public:
  explicit TopLevelProcessContext(StringPtr programName);

  struct CleanShutdownException { int exitCode; };





  StringPtr getProgramName() override;
  void exit() override __attribute__((noreturn));
  void warning(StringPtr message) override;
  void error(StringPtr message) override;
  void exitError(StringPtr message) override __attribute__((noreturn));
  void exitInfo(StringPtr message) override __attribute__((noreturn));
  void increaseLoggingVerbosity() override;

private:
  StringPtr programName;
  bool cleanShutdown;
  bool hadErrors = false;
};

typedef Function<void(StringPtr programName, ArrayPtr<const StringPtr> params)> MainFunc;

int runMainAndExit(ProcessContext& context, MainFunc&& func, int argc, char* argv[]);
# 175 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
#define KJ_MAIN(MainClass) int main(int argc, char* argv[]) { ::kj::TopLevelProcessContext context(argv[0]); MainClass mainObject(context); return ::kj::runMainAndExit(context, mainObject.getMain(), argc, argv); }
# 185 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
class MainBuilder {
# 248 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
public:
  MainBuilder(ProcessContext& context, StringPtr version,
              StringPtr briefDescription, StringPtr extendedDescription = nullptr);
  ~MainBuilder() noexcept(false);

  class OptionName {
  public:
    OptionName() = default;
    inline OptionName(char shortName): isLong(false), shortName(shortName) {}
    inline OptionName(const char* longName): isLong(true), longName(longName) {}

  private:
    bool isLong;
    union {
      char shortName;
      const char* longName;
    };
    friend class MainBuilder;
  };

  class Validity {
  public:
    inline Validity(bool valid) {
      if (!valid) errorMessage = heapString("invalid argument");
    }
    inline Validity(const char* errorMessage)
        : errorMessage(heapString(errorMessage)) {}
    inline Validity(String&& errorMessage)
        : errorMessage(kj::mv(errorMessage)) {}

    inline const Maybe<String>& getError() const { return errorMessage; }
    inline Maybe<String> releaseError() { return kj::mv(errorMessage); }

  private:
    Maybe<String> errorMessage;
    friend class MainBuilder;
  };

  MainBuilder& addOption(std::initializer_list<OptionName> names, Function<Validity()> callback,
                         StringPtr helpText);
# 315 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
  MainBuilder& addOptionWithArg(std::initializer_list<OptionName> names,
                                Function<Validity(StringPtr)> callback,
                                StringPtr argumentTitle, StringPtr helpText);
# 342 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
  MainBuilder& addSubCommand(StringPtr name, Function<MainFunc()> getSubParser,
                             StringPtr briefHelpText);
# 356 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
  MainBuilder& expectArg(StringPtr title, Function<Validity(StringPtr)> callback);
  MainBuilder& expectOptionalArg(StringPtr title, Function<Validity(StringPtr)> callback);
  MainBuilder& expectZeroOrMoreArgs(StringPtr title, Function<Validity(StringPtr)> callback);
  MainBuilder& expectOneOrMoreArgs(StringPtr title, Function<Validity(StringPtr)> callback);
# 391 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/../kj/main.h" 3
  MainBuilder& callAfterParsing(Function<Validity()> callback);


  MainFunc build();



private:
  struct Impl;
  Own<Impl> impl;

  class MainImpl;
};

}
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/algorithm" 1 3
# 56 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/algorithm" 3
#define _GLIBCXX_ALGORITHM 1
# 59 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/algorithm" 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
#define _STL_ALGO_H 1


# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 1 3
# 40 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/cstdlib" 3
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/algorithmfwd.h" 1 3
# 31 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/algorithmfwd.h" 3
#define _GLIBCXX_ALGORITHMFWD_H 1
# 34 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/algorithmfwd.h" 3








namespace std __attribute__ ((__visibility__ ("default")))
{
# 195 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
# 224 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/algorithmfwd.h" 3
  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>

    const _Tp&
    max(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>

    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>

    const _Tp&
    min(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>

    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>

    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>

    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&, _Compare);

  template<typename _FIter>

    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>

    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter, _Compare);

  template<typename _Tp>

    _Tp
    min(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>

    _Tp
    min(initializer_list<_Tp>, _Compare);

  template<typename _Tp>

    _Tp
    max(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>

    _Tp
    max(initializer_list<_Tp>, _Compare);

  template<typename _Tp>

    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>

    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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>

    _FIter
    max_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>

    _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>

    _FIter
    min_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>

    _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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_heap.h" 1 3
# 56 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_heap.h" 3
#define _STL_HEAP_H 1





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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tempbuf.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tempbuf.h" 3
#define _STL_TEMPBUF_H 1



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_construct.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_construct.h" 3
#define _STL_CONSTRUCT_H 1





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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
    }
# 233 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_construct.h" 3
}
# 61 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tempbuf.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 83 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 2 3



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uniform_int_dist.h" 1 3
# 32 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uniform_int_dist.h" 3
#define _GLIBCXX_BITS_UNIFORM_INT_DIST_H 



# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 1 3
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
#define _GLIBCXX_NUMERIC_LIMITS 1
# 41 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
# 80 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
#define __glibcxx_integral_traps true
# 89 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
#define __glibcxx_float_has_denorm_loss false


#define __glibcxx_float_traps false


#define __glibcxx_float_tinyness_before false







#define __glibcxx_double_has_denorm_loss false


#define __glibcxx_double_traps false


#define __glibcxx_double_tinyness_before false







#define __glibcxx_long_double_has_denorm_loss false


#define __glibcxx_long_double_traps false


#define __glibcxx_long_double_tinyness_before false




#define __glibcxx_signed_b(T,B) ((T)(-1) < 0)

#define __glibcxx_min_b(T,B) (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0)


#define __glibcxx_max_b(T,B) (__glibcxx_signed_b (T,B) ? (((((T)1 << (__glibcxx_digits_b (T,B) - 1)) - 1) << 1) + 1) : ~(T)0)



#define __glibcxx_digits_b(T,B) (B - __glibcxx_signed_b (T,B))



#define __glibcxx_digits10_b(T,B) (__glibcxx_digits_b (T,B) * 643L / 2136)


#define __glibcxx_signed(T) __glibcxx_signed_b (T, sizeof(T) * __CHAR_BIT__)

#define __glibcxx_min(T) __glibcxx_min_b (T, sizeof(T) * __CHAR_BIT__)

#define __glibcxx_max(T) __glibcxx_max_b (T, sizeof(T) * __CHAR_BIT__)

#define __glibcxx_digits(T) __glibcxx_digits_b (T, sizeof(T) * __CHAR_BIT__)

#define __glibcxx_digits10(T) __glibcxx_digits10_b (T, sizeof(T) * __CHAR_BIT__)


#define __glibcxx_max_digits10(T) (2 + (T) * 643L / 2136)


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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
  template<>
    struct numeric_limits<bool>
    {
      static constexpr bool is_specialized = true;

      static constexpr bool
      min() noexcept { return false; }

      static constexpr bool
      max() noexcept { return true; }


      static constexpr bool
      lowest() noexcept { return min(); }

      static constexpr int digits = 1;
      static constexpr int digits10 = 0;

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr bool
      epsilon() noexcept { return false; }

      static constexpr bool
      round_error() noexcept { return false; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr bool
      infinity() noexcept { return false; }

      static constexpr bool
      quiet_NaN() noexcept { return false; }

      static constexpr bool
      signaling_NaN() noexcept { return false; }

      static constexpr bool
      denorm_min() noexcept { return false; }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;




      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<char>
    {
      static constexpr bool is_specialized = true;

      static constexpr char
      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }

      static constexpr char
      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }


      static constexpr char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((char)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char
      epsilon() noexcept { return 0; }

      static constexpr char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr
      char infinity() noexcept { return char(); }

      static constexpr char
      quiet_NaN() noexcept { return char(); }

      static constexpr char
      signaling_NaN() noexcept { return char(); }

      static constexpr char
      denorm_min() noexcept { return static_cast<char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<signed char>
    {
      static constexpr bool is_specialized = true;

      static constexpr signed char
      min() noexcept { return -127 - 1; }

      static constexpr signed char
      max() noexcept { return 127; }


      static constexpr signed char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr signed char
      epsilon() noexcept { return 0; }

      static constexpr signed char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr signed char
      infinity() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      quiet_NaN() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      signaling_NaN() noexcept
      { return static_cast<signed char>(0); }

      static constexpr signed char
      denorm_min() noexcept
      { return static_cast<signed char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned char>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned char
      min() noexcept { return 0; }

      static constexpr unsigned char
      max() noexcept { return 127 * 2U + 1; }


      static constexpr unsigned char
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned char
      epsilon() noexcept { return 0; }

      static constexpr unsigned char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned char
      infinity() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      quiet_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      signaling_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      denorm_min() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<wchar_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr wchar_t
      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }

      static constexpr wchar_t
      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }


      static constexpr wchar_t
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr wchar_t
      epsilon() noexcept { return 0; }

      static constexpr wchar_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr wchar_t
      infinity() noexcept { return wchar_t(); }

      static constexpr wchar_t
      quiet_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      signaling_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      denorm_min() noexcept { return wchar_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };



  template<>
    struct numeric_limits<char16_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char16_t
      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }

      static constexpr char16_t
      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }

      static constexpr char16_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char16_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char16_t
      epsilon() noexcept { return 0; }

      static constexpr char16_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char16_t
      infinity() noexcept { return char16_t(); }

      static constexpr char16_t
      quiet_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      signaling_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      denorm_min() noexcept { return char16_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<char32_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char32_t
      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }

      static constexpr char32_t
      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }

      static constexpr char32_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char32_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char32_t
      epsilon() noexcept { return 0; }

      static constexpr char32_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char32_t
      infinity() noexcept { return char32_t(); }

      static constexpr char32_t
      quiet_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      signaling_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      denorm_min() noexcept { return char32_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };



  template<>
    struct numeric_limits<short>
    {
      static constexpr bool is_specialized = true;

      static constexpr short
      min() noexcept { return -32767 - 1; }

      static constexpr short
      max() noexcept { return 32767; }


      static constexpr short
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr short
      epsilon() noexcept { return 0; }

      static constexpr short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr short
      infinity() noexcept { return short(); }

      static constexpr short
      quiet_NaN() noexcept { return short(); }

      static constexpr short
      signaling_NaN() noexcept { return short(); }

      static constexpr short
      denorm_min() noexcept { return short(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned short>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned short
      min() noexcept { return 0; }

      static constexpr unsigned short
      max() noexcept { return 32767 * 2U + 1; }


      static constexpr unsigned short
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned short
      epsilon() noexcept { return 0; }

      static constexpr unsigned short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned short
      infinity() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      quiet_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      signaling_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      denorm_min() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<int>
    {
      static constexpr bool is_specialized = true;

      static constexpr int
      min() noexcept { return -2147483647 - 1; }

      static constexpr int
      max() noexcept { return 2147483647; }


      static constexpr int
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr int
      epsilon() noexcept { return 0; }

      static constexpr int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr int
      infinity() noexcept { return static_cast<int>(0); }

      static constexpr int
      quiet_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      signaling_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      denorm_min() noexcept { return static_cast<int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned int>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned int
      min() noexcept { return 0; }

      static constexpr unsigned int
      max() noexcept { return 2147483647 * 2U + 1; }


      static constexpr unsigned int
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned int
      epsilon() noexcept { return 0; }

      static constexpr unsigned int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned int
      infinity() noexcept { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      quiet_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      signaling_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      denorm_min() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long
      min() noexcept { return -9223372036854775807L - 1; }

      static constexpr long
      max() noexcept { return 9223372036854775807L; }


      static constexpr long
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long
      epsilon() noexcept { return 0; }

      static constexpr long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long
      infinity() noexcept { return static_cast<long>(0); }

      static constexpr long
      quiet_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      signaling_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      denorm_min() noexcept { return static_cast<long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long
      min() noexcept { return 0; }

      static constexpr unsigned long
      max() noexcept { return 9223372036854775807L * 2UL + 1; }


      static constexpr unsigned long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long
      infinity() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      quiet_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      signaling_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      denorm_min() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long long
      min() noexcept { return -9223372036854775807LL - 1; }

      static constexpr long long
      max() noexcept { return 9223372036854775807LL; }


      static constexpr long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long long
      epsilon() noexcept { return 0; }

      static constexpr long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long long
      infinity() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      quiet_NaN() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      signaling_NaN() noexcept
      { return static_cast<long long>(0); }

      static constexpr long long
      denorm_min() noexcept { return static_cast<long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long long
      min() noexcept { return 0; }

      static constexpr unsigned long long
      max() noexcept { return 9223372036854775807LL * 2ULL + 1; }


      static constexpr unsigned long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long long
      infinity() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      quiet_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      signaling_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      denorm_min() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };



#define __INT_N(TYPE,BITSIZE,EXT,UEXT) template<> struct numeric_limits<TYPE> { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR TYPE min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } static _GLIBCXX_CONSTEXPR TYPE max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } static _GLIBCXX_USE_CONSTEXPR int digits = BITSIZE - 1; static _GLIBCXX_USE_CONSTEXPR int digits10 = (BITSIZE - 1) * 643L / 2136; static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR TYPE epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR TYPE round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } EXT static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR TYPE infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_CONSTEXPR TYPE quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_CONSTEXPR TYPE signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_CONSTEXPR TYPE denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<TYPE>(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits<unsigned TYPE> { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned TYPE min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned TYPE max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } UEXT static _GLIBCXX_USE_CONSTEXPR int digits = BITSIZE; static _GLIBCXX_USE_CONSTEXPR int digits10 = BITSIZE * 643L / 2136; static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned TYPE epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned TYPE round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned TYPE infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_CONSTEXPR unsigned TYPE quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_CONSTEXPR unsigned TYPE signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_CONSTEXPR unsigned TYPE denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast<unsigned TYPE>(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; };
# 1554 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
#define __INT_N_201103(TYPE) static constexpr TYPE lowest() noexcept { return min(); } static constexpr int max_digits10 = 0;




#define __INT_N_U201103(TYPE) static constexpr unsigned TYPE lowest() noexcept { return min(); } static constexpr int max_digits10 = 0;
# 1570 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
 template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits<unsigned __int128> { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast<unsigned __int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; };
# 1586 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/limits" 3
#undef __INT_N
#undef __INT_N_201103
#undef __INT_N_U201103




 template<>
    struct numeric_limits<float>
    {
      static constexpr bool is_specialized = true;

      static constexpr float
      min() noexcept { return 1.17549435e-38F; }

      static constexpr float
      max() noexcept { return 3.40282347e+38F; }


      static constexpr float
      lowest() noexcept { return -3.40282347e+38F; }


      static constexpr int digits = 24;
      static constexpr int digits10 = 6;

      static constexpr int max_digits10
  = (2 + (24) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr float
      epsilon() noexcept { return 1.19209290e-7F; }

      static constexpr float
      round_error() noexcept { return 0.5F; }

      static constexpr int min_exponent = (-125);
      static constexpr int min_exponent10 = (-37);
      static constexpr int max_exponent = 128;
      static constexpr int max_exponent10 = 38;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
       = false;

      static constexpr float
      infinity() noexcept { return __builtin_huge_valf(); }

      static constexpr float
      quiet_NaN() noexcept { return __builtin_nanf(""); }

      static constexpr float
      signaling_NaN() noexcept { return __builtin_nansf(""); }

      static constexpr float
      denorm_min() noexcept { return 1.40129846e-45F; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before
       = false;
      static constexpr float_round_style round_style
       = round_to_nearest;
    };

#undef __glibcxx_float_has_denorm_loss
#undef __glibcxx_float_traps
#undef __glibcxx_float_tinyness_before


 template<>
    struct numeric_limits<double>
    {
      static constexpr bool is_specialized = true;

      static constexpr double
      min() noexcept { return 2.2250738585072014e-308; }

      static constexpr double
      max() noexcept { return 1.7976931348623157e+308; }


      static constexpr double
      lowest() noexcept { return -1.7976931348623157e+308; }


      static constexpr int digits = 53;
      static constexpr int digits10 = 15;

      static constexpr int max_digits10
  = (2 + (53) * 643L / 2136);

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr double
      epsilon() noexcept { return 2.2204460492503131e-16; }

      static constexpr double
      round_error() noexcept { return 0.5; }

      static constexpr int min_exponent = (-1021);
      static constexpr int min_exponent10 = (-307);
      static constexpr int max_exponent = 1024;
      static constexpr int max_exponent10 = 308;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;
      static constexpr bool has_signaling_NaN = has_quiet_NaN;
      static constexpr float_denorm_style has_denorm
 = bool(1) ? denorm_present : denorm_absent;
      static constexpr bool has_denorm_loss
        = false;

      static constexpr double
      infinity() noexcept { return __builtin_huge_val(); }

      static constexpr double
      quiet_NaN() noexcept { return __builtin_nan(""); }

      static constexpr double
      signaling_NaN() noexcept { return __builtin_nans(""); }

      static constexpr double
      denorm_min() noexcept { return 4.9406564584124654e-324; }

      static constexpr bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = false;
      static constexpr bool tinyness_before
       = false;
      static constexpr float_round_style round_style
       = round_to_nearest;
    };

#undef __glibcxx_double_has_denorm_loss
#undef __glibcxx_double_traps
#undef __glibcxx_double_tinyness_before


 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.18973149535723176508575932662800702e+4932L; }


      static constexpr long double
      lowest() noexcept { return -1.18973149535723176508575932662800702e+4932L; }


      static constexpr int digits = 113;
      static constexpr int digits10 = 33;

      static constexpr int max_digits10
  = (2 + (113) * 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.92592994438723585305597794258492732e-34L; }

      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 6.47517511943802511092443895822764655e-4966L; }

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

#undef __glibcxx_long_double_has_denorm_loss
#undef __glibcxx_long_double_traps
#undef __glibcxx_long_double_tinyness_before


}

#undef __glibcxx_signed
#undef __glibcxx_min
#undef __glibcxx_max
#undef __glibcxx_digits
#undef __glibcxx_digits10
#undef __glibcxx_max_digits10
# 36 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uniform_int_dist.h" 2 3

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

  namespace __detail
  {


    template<typename _Tp>
      inline bool
      _Power_of_2(_Tp __x)
      {
 return ((__x - 1) & __x) == 0;
      };

  }
# 60 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/uniform_int_dist.h" 3
  template<typename _IntType = int>
    class uniform_int_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "template argument must be an integral type");

    public:

      typedef _IntType result_type;

      struct param_type
      {
 typedef uniform_int_distribution<_IntType> distribution_type;

 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)
   {
# 267 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
   {
# 351 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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, ++__first)
 if (!__pred(__first))
   break;
      return __first;
    }
# 202 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 840 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__out_true = *__first;
     ++__out_true;
   }
 else
   {
     *__out_false = *__first;
     ++__out_false;
   }

      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
    }


  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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {



                                                     ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1205 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 1755 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                     ;
                                                     ;
                                                                   ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
          __gnu_cxx::__ops::__iter_less_iter());
    }
# 1784 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 1809 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {
# 2838 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 2868 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 2884 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 2903 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _Tp>

    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>

    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>

    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator>

    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 3428 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>

    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>

    inline _Tp
    min(initializer_list<_Tp> __l)
    { return *std::min_element(__l.begin(), __l.end()); }

  template<typename _Tp, typename _Compare>

    inline _Tp
    min(initializer_list<_Tp> __l, _Compare __comp)
    { return *std::min_element(__l.begin(), __l.end(), __comp); }

  template<typename _Tp>

    inline _Tp
    max(initializer_list<_Tp> __l)
    { return *std::max_element(__l.begin(), __l.end()); }

  template<typename _Tp, typename _Compare>

    inline _Tp
    max(initializer_list<_Tp> __l, _Compare __comp)
    { return *std::max_element(__l.begin(), __l.end(), __comp); }

  template<typename _Tp>

    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>

    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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 3767 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)));
    }
# 3876 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 3897 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 3921 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 3952 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 3992 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 4024 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 4049 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4074 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4097 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4137 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 4176 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4211 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4244 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4292 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 4329 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 4362 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 4394 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
    }
# 4426 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {




                                                     ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 4457 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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, ++__first)
 *__first = __gen();
      return __first;
    }
# 4493 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4533 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4566 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
   }
    }
# 4601 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
 }
    }
# 4641 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4674 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 4712 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4748 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 4787 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4824 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 4854 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 4915 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 4932 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__merge(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 4965 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 4982 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__merge(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      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);
    }
# 5029 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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());
    }
# 5063 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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));
    }
# 5131 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5151 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5180 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5200 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    _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;
    }
# 5250 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5268 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_intersection(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 5298 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5316 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_intersection(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    _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);
    }
# 5370 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5388 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 5420 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5438 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    _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));
    }
# 5498 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5518 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_symmetric_difference(__first1, __last1,
     __first2, __last2, __result,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 5548 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)
    {
# 5569 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_symmetric_difference(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>

    _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;
    }
# 5601 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator>

    _ForwardIterator
    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5626 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>

    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>

    _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;
    }
# 5665 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator>

    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5690 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>

    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 5834 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_algo.h" 3
}
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/algorithm" 2 3
# 37 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/map" 1 3
# 56 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/map" 3
#define _GLIBCXX_MAP 1
# 59 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/map" 3

# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 1 3
# 59 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
#define _STL_TREE_H 1
# 62 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
# 75 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 99 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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 ();
# 442 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc = allocator<_Val> >
    class _Rb_tree
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
        rebind<_Rb_tree_node<_Val> >::other _Node_allocator;

      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;

    protected:
      typedef _Rb_tree_node_base* _Base_ptr;
      typedef const _Rb_tree_node_base* _Const_Base_ptr;
      typedef _Rb_tree_node<_Val>* _Link_type;
      typedef const _Rb_tree_node<_Val>* _Const_Link_type;

    private:


      struct _Reuse_or_alloc_node
      {
 _Reuse_or_alloc_node(_Rb_tree& __t)
   : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
 {
   if (_M_root)
     {
       _M_root->_M_parent = 0;

       if (_M_nodes->_M_left)
  _M_nodes = _M_nodes->_M_left;
     }
   else
     _M_nodes = 0;
 }


 _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;


 ~_Reuse_or_alloc_node()
 { _M_t._M_erase(static_cast<_Link_type>(_M_root)); }

 template<typename _Arg>
   _Link_type



   operator()(_Arg&& __arg)

   {
     _Link_type __node = static_cast<_Link_type>(_M_extract());
     if (__node)
       {
  _M_t._M_destroy_node(__node);
  _M_t._M_construct_node(__node, std::forward<_Arg>(__arg));
  return __node;
       }

     return _M_t._M_create_node(std::forward<_Arg>(__arg));
   }

      private:
 _Base_ptr
 _M_extract()
 {
   if (!_M_nodes)
     return _M_nodes;

   _Base_ptr __node = _M_nodes;
   _M_nodes = _M_nodes->_M_parent;
   if (_M_nodes)
     {
       if (_M_nodes->_M_right == __node)
  {
    _M_nodes->_M_right = 0;

    if (_M_nodes->_M_left)
      {
        _M_nodes = _M_nodes->_M_left;

        while (_M_nodes->_M_right)
   _M_nodes = _M_nodes->_M_right;

        if (_M_nodes->_M_left)
   _M_nodes = _M_nodes->_M_left;
      }
  }
       else
  _M_nodes->_M_left = 0;
     }
   else
     _M_root = 0;

   return __node;
 }

 _Base_ptr _M_root;
 _Base_ptr _M_nodes;
 _Rb_tree& _M_t;
      };



      struct _Alloc_node
      {
 _Alloc_node(_Rb_tree& __t)
   : _M_t(__t) { }

 template<typename _Arg>
   _Link_type



   operator()(_Arg&& __arg) const

   { return _M_t._M_create_node(std::forward<_Arg>(__arg)); }

      private:
 _Rb_tree& _M_t;
      };

    public:
      typedef _Key key_type;
      typedef _Val value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

      _Node_allocator&
      _M_get_Node_allocator() noexcept
      { return *static_cast<_Node_allocator*>(&this->_M_impl); }

      const _Node_allocator&
      _M_get_Node_allocator() const noexcept
      { return *static_cast<const _Node_allocator*>(&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); }
# 619 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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() = default;
   _Rb_tree_impl(_Rb_tree_impl&&) = default;


   _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(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;
# 816 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
      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);
# 867 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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);
# 1087 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 1143 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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();
      }
# 1165 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 1325 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
      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);
# 1528 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
    };

  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;
    }
# 2612 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_tree.h" 3
}
# 61 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/map" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
#define _STL_MAP_H 1








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


  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class multimap;
# 97 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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:
# 120 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
    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;
# 177 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)) { }
# 199 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      map(const map&) = default;







      map(map&&) = default;
# 220 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 264 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_unique(__first, __last); }
# 281 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 310 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      map&
      operator=(const map&) = default;


      map&
      operator=(map&&) = default;
# 328 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }
# 483 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 528 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
      }
# 566 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)...); }
# 596 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)...);
 }
# 794 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__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)); }
# 815 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      void
      insert(std::initializer_list<value_type> __list)
      { insert(__list.begin(), __list.end()); }
# 843 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      iterator

      insert(const_iterator __position, const value_type& __x)



      { return _M_t._M_insert_unique_(__position, __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)); }
# 869 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_unique(__first, __last); }
# 1009 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1046 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 1066 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 1100 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 1147 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 1172 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 1193 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 1217 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 1242 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }
# 1262 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }
# 1282 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }
# 1311 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 1340 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }
# 1357 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
      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>&);
    };
# 1378 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 1395 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1462 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_map.h" 3
}
# 62 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/map" 2 3
# 1 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 1 3
# 57 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
#define _STL_MULTIMAP_H 1






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


  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class map;
# 95 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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:
# 119 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
    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;
# 174 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)) { }
# 196 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      multimap(const multimap&) = default;
# 205 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      multimap(multimap&&) = default;
# 217 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 260 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_equal(__first, __last); }
# 276 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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;
# 305 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap&) = default;


      multimap&
      operator=(multimap&&) = default;
# 323 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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(); }
# 481 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 508 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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)...);
 }
# 529 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__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)); }
# 562 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      iterator

      insert(const_iterator __position, const value_type& __x)



      { return _M_t._M_insert_equal_(__position, __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)); }
# 589 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_equal(__first, __last); }
# 602 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }
# 679 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 716 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 737 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 774 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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()); }
# 820 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 844 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 862 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 886 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 911 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }
# 931 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }
# 951 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }
# 978 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 1005 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }
# 1022 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
      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>&);
  };
# 1043 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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; }
# 1060 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/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); }
# 1127 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/bits/stl_multimap.h" 3
}
# 63 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/recipe-sysroot/usr/lib//aarch64-bec-linux-musl/7.2.0/../../../include/c++/7.2.0/map" 2 3
# 38 "/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++" 2






#define VERSION "(unknown)"


namespace capnp {
namespace {

bool hasDiscriminantValue(const schema::Field::Reader& reader) {
  return reader.getDiscriminantValue() != schema::Field::NO_DISCRIMINANT;
}

struct Indent {
  uint amount;
  Indent() = default;
  inline Indent(int amount): amount(amount) {}

  Indent next() {
    return Indent(amount + 2);
  }

  struct Iterator {
    uint i;
    Iterator() = default;
    inline Iterator(uint i): i(i) {}
    inline char operator*() const { return ' '; }
    inline Iterator& operator++() { ++i; return *this; }
    inline Iterator operator++(int) { Iterator result = *this; ++i; return result; }
    inline bool operator==(const Iterator& other) const { return i == other.i; }
    inline bool operator!=(const Iterator& other) const { return i != other.i; }
  };

  inline size_t size() const { return amount; }

  inline Iterator begin() const { return Iterator(0); }
  inline Iterator end() const { return Iterator(amount); }
};

inline Indent operator*(::kj::_::Stringifier, const Indent& indent) {
  return indent;
}



class CapnpcCapnpMain {
public:
  CapnpcCapnpMain(kj::ProcessContext& context): context(context) {}

  kj::MainFunc getMain() {
    return kj::MainBuilder(context, "Cap'n Proto loopback plugin version " "(unknown)",
          "This is a Cap'n Proto compiler plugin which \"de-compiles\" the schema back into "
          "Cap'n Proto schema language format, with comments showing the offsets chosen by the "
          "compiler.  This is meant to be run using the Cap'n Proto compiler, e.g.:\n"
          "    capnp compile -ocapnp foo.capnp")
        .callAfterParsing(::kj::_::BoundMethod<decltype(::kj::_::refIfLvalue(*this)), decltype(&::kj::Decay<decltype(*this)>::run), &::kj::Decay<decltype(*this)>::run>(*this))
        .build();
  }

private:
  kj::ProcessContext& context;
  SchemaLoader schemaLoader;

  Text::Reader getUnqualifiedName(Schema schema) {
    auto proto = schema.getProto();
    auto _kjContextFunc106 = [&]() -> ::kj::_::Debug::Context::Value { return ::kj::_::Debug::Context::Value("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 106, ::kj::_::Debug::makeDescription("proto.getDisplayName()",proto.getDisplayName())); }; ::kj::_::Debug::ContextImpl<decltype(_kjContextFunc106)> _kjContext106(_kjContextFunc106);
    auto parent = schemaLoader.get(proto.getScopeId());
    for (auto nested: parent.getProto().getNestedNodes()) {
      if (nested.getId() == proto.getId()) {
        return nested.getName();
      }
    }
    for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 113, ::kj::Exception::Type::FAILED, nullptr, "\"A schema Node's supposed scope did not contain the node as a NestedNode.\"","A schema Node's supposed scope did not contain the node as a NestedNode.");; f.fatal());
    return "(?)";
  }

  kj::StringTree nodeName(Schema target, Schema scope, schema::Brand::Reader brand,
                          kj::Maybe<InterfaceSchema::Method> method) {
    kj::Vector<Schema> targetPath;
    kj::Vector<Schema> scopeParts;

    targetPath.add(target);

    std::map<uint64_t, List<schema::Brand::Binding>::Reader> scopeBindings;
    for (auto scopeBrand: brand.getScopes()) {
      switch (scopeBrand.which()) {
        case schema::Brand::Scope::BIND:
          scopeBindings[scopeBrand.getScopeId()] = scopeBrand.getBind();
          break;
        case schema::Brand::Scope::INHERIT:



          break;
      }
    }

    {
      Schema parent = target;
      while (parent.getProto().getScopeId() != 0) {
        parent = schemaLoader.get(parent.getProto().getScopeId());
        targetPath.add(parent);
      }
    }

    {
      Schema parent = scope;
      scopeParts.add(parent);
      while (parent.getProto().getScopeId() != 0) {
        parent = schemaLoader.get(parent.getProto().getScopeId());
        scopeParts.add(parent);
      }
    }



    while (!scopeParts.empty() && targetPath.size() > 1 &&
           scopeParts.back() == targetPath.back() &&
           scopeBindings.count(scopeParts.back().getProto().getId()) == 0) {
      scopeParts.removeLast();
      targetPath.removeLast();
    }

    auto parts = kj::heapArrayBuilder<kj::StringTree>(targetPath.size());
    while (!targetPath.empty()) {
      auto part = targetPath.back();
      auto proto = part.getProto();
      kj::StringTree partStr;
      if (proto.getScopeId() == 0) {
        partStr = kj::strTree("import \"/", proto.getDisplayName(), '\"');
      } else {
        partStr = kj::strTree(getUnqualifiedName(part));
      }

      auto iter = scopeBindings.find(proto.getId());
      if (iter != scopeBindings.end()) {
        auto bindings = ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(iter->second))>(iter->second) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(iter->second))>::Element binding) {
          switch (binding.which()) {
            case schema::Brand::Binding::UNBOUND:
              return kj::strTree("AnyPointer");
            case schema::Brand::Binding::TYPE:
              return genType(binding.getType(), scope, method);
          }
          return kj::strTree("<unknown binding>");
        };
        partStr = kj::strTree(kj::mv(partStr), "(", kj::StringTree(kj::mv(bindings), ", "), ")");
      }

      parts.add(kj::mv(partStr));
      targetPath.removeLast();
    }

    return kj::StringTree(parts.finish(), ".");
  }

  kj::StringTree genType(schema::Type::Reader type, Schema scope,
                         kj::Maybe<InterfaceSchema::Method> method) {
    switch (type.which()) {
      case schema::Type::VOID: return kj::strTree("Void");
      case schema::Type::BOOL: return kj::strTree("Bool");
      case schema::Type::INT8: return kj::strTree("Int8");
      case schema::Type::INT16: return kj::strTree("Int16");
      case schema::Type::INT32: return kj::strTree("Int32");
      case schema::Type::INT64: return kj::strTree("Int64");
      case schema::Type::UINT8: return kj::strTree("UInt8");
      case schema::Type::UINT16: return kj::strTree("UInt16");
      case schema::Type::UINT32: return kj::strTree("UInt32");
      case schema::Type::UINT64: return kj::strTree("UInt64");
      case schema::Type::FLOAT32: return kj::strTree("Float32");
      case schema::Type::FLOAT64: return kj::strTree("Float64");
      case schema::Type::TEXT: return kj::strTree("Text");
      case schema::Type::DATA: return kj::strTree("Data");
      case schema::Type::LIST:
        return kj::strTree("List(", genType(type.getList().getElementType(), scope, method), ")");
      case schema::Type::ENUM:
        return nodeName(schemaLoader.get(type.getEnum().getTypeId()), scope,
                        type.getEnum().getBrand(), method);
      case schema::Type::STRUCT:
        return nodeName(schemaLoader.get(type.getStruct().getTypeId()), scope,
                        type.getStruct().getBrand(), method);
      case schema::Type::INTERFACE:
        return nodeName(schemaLoader.get(type.getInterface().getTypeId()), scope,
                        type.getInterface().getBrand(), method);
      case schema::Type::ANY_POINTER: {
        auto anyPointer = type.getAnyPointer();
        switch (anyPointer.which()) {
          case schema::Type::AnyPointer::UNCONSTRAINED:
            switch (anyPointer.getUnconstrained().which()) {
              case schema::Type::AnyPointer::Unconstrained::ANY_KIND:
                return kj::strTree("AnyPointer");
              case schema::Type::AnyPointer::Unconstrained::STRUCT:
                return kj::strTree("AnyStruct");
              case schema::Type::AnyPointer::Unconstrained::LIST:
                return kj::strTree("AnyList");
              case schema::Type::AnyPointer::Unconstrained::CAPABILITY:
                return kj::strTree("Capability");
            }
            ::kj::_::unreachable();;
          case schema::Type::AnyPointer::PARAMETER: {
            auto param = anyPointer.getParameter();
            auto scopeProto = scope.getProto();
            auto targetScopeId = param.getScopeId();
            while (scopeProto.getId() != targetScopeId) {
              scopeProto = schemaLoader.get(param.getScopeId()).getProto();
            }
            auto params = scopeProto.getParameters();
            if (__builtin_expect(param.getParameterIndex() < params.size(), true)) {} else for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 247, ::kj::Exception::Type::FAILED, "param.getParameterIndex() < params.size()", "");; f.fatal());
            return kj::strTree(params[param.getParameterIndex()].getName());
          }
          case schema::Type::AnyPointer::IMPLICIT_METHOD_PARAMETER: {
            auto params = (*({ auto _kj_result = ::kj::_::readMaybe(method); if (__builtin_expect(!_kj_result, false)) { ::kj::_::Debug::Fault("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 251, ::kj::Exception::Type::FAILED, "method" " != nullptr", "").fatal(); } kj::mv(_kj_result); })).getProto().getImplicitParameters();
            uint index = anyPointer.getImplicitMethodParameter().getParameterIndex();
            if (__builtin_expect(index < params.size(), true)) {} else for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 253, ::kj::Exception::Type::FAILED, "index < params.size()", "");; f.fatal());
            return kj::strTree(params[index].getName());
          }
        }
        ::kj::_::unreachable();;
      }
    }
    return kj::strTree();
  }

  int typeSizeBits(schema::Type::Reader type) {
    switch (type.which()) {
      case schema::Type::VOID: return 0;
      case schema::Type::BOOL: return 1;
      case schema::Type::INT8: return 8;
      case schema::Type::INT16: return 16;
      case schema::Type::INT32: return 32;
      case schema::Type::INT64: return 64;
      case schema::Type::UINT8: return 8;
      case schema::Type::UINT16: return 16;
      case schema::Type::UINT32: return 32;
      case schema::Type::UINT64: return 64;
      case schema::Type::FLOAT32: return 32;
      case schema::Type::FLOAT64: return 64;
      case schema::Type::TEXT: return -1;
      case schema::Type::DATA: return -1;
      case schema::Type::LIST: return -1;
      case schema::Type::ENUM: return 16;
      case schema::Type::STRUCT: return -1;
      case schema::Type::INTERFACE: return -1;
      case schema::Type::ANY_POINTER: return -1;
    }
    return 0;
  }

  bool isEmptyValue(schema::Value::Reader value) {
    switch (value.which()) {
      case schema::Value::VOID: return true;
      case schema::Value::BOOL: return value.getBool() == false;
      case schema::Value::INT8: return value.getInt8() == 0;
      case schema::Value::INT16: return value.getInt16() == 0;
      case schema::Value::INT32: return value.getInt32() == 0;
      case schema::Value::INT64: return value.getInt64() == 0;
      case schema::Value::UINT8: return value.getUint8() == 0;
      case schema::Value::UINT16: return value.getUint16() == 0;
      case schema::Value::UINT32: return value.getUint32() == 0;
      case schema::Value::UINT64: return value.getUint64() == 0;
      case schema::Value::FLOAT32: return value.getFloat32() == 0;
      case schema::Value::FLOAT64: return value.getFloat64() == 0;
      case schema::Value::TEXT: return !value.hasText();
      case schema::Value::DATA: return !value.hasData();
      case schema::Value::LIST: return !value.hasList();
      case schema::Value::ENUM: return value.getEnum() == 0;
      case schema::Value::STRUCT: return !value.hasStruct();
      case schema::Value::INTERFACE: return true;
      case schema::Value::ANY_POINTER: return true;
    }
    return true;
  }

  kj::StringTree genValue(Type type, schema::Value::Reader value) {
    switch (value.which()) {
      case schema::Value::VOID: return kj::strTree("void");
      case schema::Value::BOOL:
        return kj::strTree(value.getBool() ? "true" : "false");
      case schema::Value::INT8: return kj::strTree((int)value.getInt8());
      case schema::Value::INT16: return kj::strTree(value.getInt16());
      case schema::Value::INT32: return kj::strTree(value.getInt32());
      case schema::Value::INT64: return kj::strTree(value.getInt64());
      case schema::Value::UINT8: return kj::strTree((uint)value.getUint8());
      case schema::Value::UINT16: return kj::strTree(value.getUint16());
      case schema::Value::UINT32: return kj::strTree(value.getUint32());
      case schema::Value::UINT64: return kj::strTree(value.getUint64());
      case schema::Value::FLOAT32: return kj::strTree(value.getFloat32());
      case schema::Value::FLOAT64: return kj::strTree(value.getFloat64());
      case schema::Value::TEXT:
        return kj::strTree(DynamicValue::Reader(value.getText()));
      case schema::Value::DATA:
        return kj::strTree(DynamicValue::Reader(value.getData()));
      case schema::Value::LIST: {
        auto listValue = value.getList().getAs<DynamicList>(type.asList());
        return kj::strTree(listValue);
      }
      case schema::Value::ENUM: {
        auto enumNode = type.asEnum().getProto();
        auto enumerants = enumNode.getEnum().getEnumerants();
        if (__builtin_expect(value.getEnum() < enumerants.size(), true)) {} else for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 340, ::kj::Exception::Type::FAILED, "value.getEnum() < enumerants.size()", "\"Enum value out-of-range.\", value.getEnum(), enumNode.getDisplayName()", "Enum value out-of-range.", value.getEnum(), enumNode.getDisplayName());; f.fatal());

        return kj::strTree(enumerants[value.getEnum()].getName());
      }
      case schema::Value::STRUCT: {
        if (__builtin_expect(type.which() == schema::Type::STRUCT, true)) {} else for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 344, ::kj::Exception::Type::FAILED, "type.which() == schema::Type::STRUCT", "\"type/value mismatch\"", "type/value mismatch");; f.fatal());
        auto structValue = value.getStruct().getAs<DynamicStruct>(type.asStruct());
        return kj::strTree(structValue);
      }
      case schema::Value::INTERFACE: {
        return kj::strTree("");
      }
      case schema::Value::ANY_POINTER: {
        return kj::strTree("");
      }
    }
    return kj::strTree("");
  }

  kj::StringTree genGenericParams(List<schema::Node::Parameter>::Reader params, Schema scope) {
    if (params.size() == 0) {
      return kj::strTree();
    }

    return kj::strTree(" (", kj::StringTree(
        ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(params))>(params) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(params))>::Element param) { return kj::strTree(param.getName()); }, ", "), ')');
  }
  kj::StringTree genGenericParams(Schema schema) {
    auto proto = schema.getProto();
    return genGenericParams(proto.getParameters(), schemaLoader.get(proto.getScopeId()));
  }

  kj::StringTree genAnnotation(schema::Annotation::Reader annotation,
                               Schema scope,
                               const char* prefix = " ", const char* suffix = "") {
    auto decl = schemaLoader.get(annotation.getId(), annotation.getBrand(), scope);
    auto proto = decl.getProto();
    if (__builtin_expect(proto.isAnnotation(), true)) {} else for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 376, ::kj::Exception::Type::FAILED, "proto.isAnnotation()", "");; f.fatal());
    auto annDecl = proto.getAnnotation();

    auto value = genValue(schemaLoader.getType(annDecl.getType(), decl),
                          annotation.getValue()).flatten();
    if (value.startsWith("(")) {
      return kj::strTree(prefix, "$", nodeName(decl, scope, annotation.getBrand(), nullptr),
                         value, suffix);
    } else {
      return kj::strTree(prefix, "$", nodeName(decl, scope, annotation.getBrand(), nullptr),
                         "(", value, ")", suffix);
    }
  }

  kj::StringTree genAnnotations(List<schema::Annotation>::Reader list, Schema scope) {
    return kj::strTree(::kj::_::Mapper<decltype(::kj::_::refIfLvalue(list))>(list) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(list))>::Element ann) { return genAnnotation(ann, scope); });
  }
  kj::StringTree genAnnotations(Schema schema) {
    auto proto = schema.getProto();
    return genAnnotations(proto.getAnnotations(), schemaLoader.get(proto.getScopeId()));
  }

  const char* elementSizeName(schema::ElementSize size) {
    switch (size) {
      case schema::ElementSize::EMPTY: return "void";
      case schema::ElementSize::BIT: return "1-bit";
      case schema::ElementSize::BYTE: return "8-bit";
      case schema::ElementSize::TWO_BYTES: return "16-bit";
      case schema::ElementSize::FOUR_BYTES: return "32-bit";
      case schema::ElementSize::EIGHT_BYTES: return "64-bit";
      case schema::ElementSize::POINTER: return "pointer";
      case schema::ElementSize::INLINE_COMPOSITE: return "inline composite";
    }
    return "";
  }

  struct OrderByCodeOrder {
    template <typename T>
    inline bool operator()(const T& a, const T& b) const {
      return a.getProto().getCodeOrder() < b.getProto().getCodeOrder();
    }
  };

  template <typename MemberList>
  kj::Array<decltype(kj::instance<MemberList>()[0])> sortByCodeOrder(MemberList&& list) {
    auto sorted = ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(list))>(list) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(list))>::Element item) { return item; };
    std::sort(sorted.begin(), sorted.end(), OrderByCodeOrder());
    return kj::mv(sorted);
  }

  kj::Array<kj::StringTree> genStructFields(StructSchema schema, Indent indent) {





    bool seenUnion = false;
    return ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(sortByCodeOrder(schema.getFields())))>(sortByCodeOrder(schema.getFields())) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(sortByCodeOrder(schema.getFields())))>::Element field) {
      if (hasDiscriminantValue(field.getProto())) {
        if (seenUnion) {
          return kj::strTree();
        } else {
          seenUnion = true;
          uint offset = schema.getProto().getStruct().getDiscriminantOffset();


          auto unionFields = sortByCodeOrder(schema.getUnionFields());
          return kj::strTree(
              indent, "union {  # tag bits [", offset * 16, ", ", offset * 16 + 16, ")\n",
              ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(unionFields))>(unionFields) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(unionFields))>::Element uField) {
                return genStructField(uField, schema, indent.next());
              },
              indent, "}\n");
        }
      } else {
        return genStructField(field, schema, indent);
      }
    };
  }

  kj::StringTree genStructField(StructSchema::Field field, Schema scope, Indent indent) {
    auto proto = field.getProto();
    switch (proto.which()) {
      case schema::Field::SLOT: {
        auto slot = proto.getSlot();
        int size = typeSizeBits(slot.getType());
        return kj::strTree(
            indent, proto.getName(), " @", proto.getOrdinal().getExplicit(),
            " :", genType(slot.getType(), scope, nullptr),
            isEmptyValue(slot.getDefaultValue()) ? kj::strTree("") :
                kj::strTree(" = ", genValue(field.getType(), slot.getDefaultValue())),
            genAnnotations(proto.getAnnotations(), scope),
            ";  # ", size == -1 ? kj::strTree("ptr[", slot.getOffset(), "]")
                                : kj::strTree("bits[", slot.getOffset() * size, ", ",
                                              (slot.getOffset() + 1) * size, ")"),
            hasDiscriminantValue(proto)
                ? kj::strTree(", union tag = ", proto.getDiscriminantValue()) : kj::strTree(),
            "\n");
      }
      case schema::Field::GROUP: {
        auto group = field.getType().asStruct();
        return kj::strTree(
            indent, proto.getName(),
            " :group", genAnnotations(proto.getAnnotations(), scope), " {",
            hasDiscriminantValue(proto)
                ? kj::strTree("  # union tag = ", proto.getDiscriminantValue()) : kj::strTree(),
            "\n",
            genStructFields(group, indent.next()),
            indent, "}\n");
      }
    }
    return kj::strTree();
  }

  kj::StringTree genParamList(InterfaceSchema interface, StructSchema schema,
                              schema::Brand::Reader brand, InterfaceSchema::Method method) {
    if (schema.getProto().getScopeId() == 0) {

      return kj::strTree("(", kj::StringTree(
          ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(schema.getFields()))>(schema.getFields()) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(schema.getFields()))>::Element field) {
            auto proto = field.getProto();
            auto slot = proto.getSlot();

            return kj::strTree(
                proto.getName(), " :", genType(slot.getType(), interface, nullptr),
                isEmptyValue(slot.getDefaultValue()) ? kj::strTree("") :
                    kj::strTree(" = ", genValue(field.getType(), slot.getDefaultValue())),
                genAnnotations(proto.getAnnotations(), interface));
          }, ", "), ")");
    } else {
      return nodeName(schema, interface, brand, method);
    }
  }

  kj::StringTree genSuperclasses(InterfaceSchema interface) {
    auto superclasses = interface.getProto().getInterface().getSuperclasses();
    if (superclasses.size() == 0) {
      return kj::strTree();
    } else {
      return kj::strTree(" superclasses(", kj::StringTree(
          ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(superclasses))>(superclasses) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(superclasses))>::Element superclass) {
            return nodeName(schemaLoader.get(superclass.getId()), interface,
                            superclass.getBrand(), nullptr);
          }, ", "), ")");
    }
  }

  kj::StringTree genDecl(Schema schema, Text::Reader name, uint64_t scopeId, Indent indent) {
    auto proto = schema.getProto();
    if (proto.getScopeId() != scopeId) {

      for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 527, ::kj::Exception::Type::FAILED, nullptr, "\"Aliases not implemented.\"","Aliases not implemented.");; f.fatal());
    }

    switch (proto.which()) {
      case schema::Node::FILE:
        for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 532, ::kj::Exception::Type::FAILED, nullptr, "\"Encountered nested file node.\"","Encountered nested file node.");; f.fatal());
        break;
      case schema::Node::STRUCT: {
        auto structProto = proto.getStruct();
        return kj::strTree(
            indent, "struct ", name,
            " @0x", kj::hex(proto.getId()), genGenericParams(schema),
            genAnnotations(schema), " {  # ",
            structProto.getDataWordCount() * 8, " bytes, ",
            structProto.getPointerCount(), " ptrs",
            structProto.getPreferredListEncoding() == schema::ElementSize::INLINE_COMPOSITE
                ? kj::strTree()
                : kj::strTree(", packed as ",
                              elementSizeName(structProto.getPreferredListEncoding())),
            "\n",
            genStructFields(schema.asStruct(), indent.next()),
            genNestedDecls(schema, indent.next()),
            indent, "}\n");
      }
      case schema::Node::ENUM: {
        return kj::strTree(
            indent, "enum ", name, " @0x", kj::hex(proto.getId()), genAnnotations(schema), " {\n",
            ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(sortByCodeOrder(schema.asEnum().getEnumerants())))>(sortByCodeOrder(schema.asEnum().getEnumerants())) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(sortByCodeOrder(schema.asEnum().getEnumerants())))>::Element enumerant) {
              return kj::strTree(indent.next(), enumerant.getProto().getName(), " @",
                                 enumerant.getIndex(),
                                 genAnnotations(enumerant.getProto().getAnnotations(), schema),
                                 ";\n");
            },
            genNestedDecls(schema, indent.next()),
            indent, "}\n");
      }
      case schema::Node::INTERFACE: {
        auto interface = schema.asInterface();
        return kj::strTree(
            indent, "interface ", name, " @0x", kj::hex(proto.getId()), genGenericParams(schema),
            genSuperclasses(interface),
            genAnnotations(schema), " {\n",
            ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(sortByCodeOrder(interface.getMethods())))>(sortByCodeOrder(interface.getMethods())) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(sortByCodeOrder(interface.getMethods())))>::Element method) {
              auto methodProto = method.getProto();

              auto implicits = methodProto.getImplicitParameters();
              kj::StringTree implicitsStr;
              if (implicits.size() > 0) {
                implicitsStr = kj::strTree(
                    "[", kj::StringTree(::kj::_::Mapper<decltype(::kj::_::refIfLvalue(implicits))>(implicits) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(implicits))>::Element implicit) {
                      return kj::strTree(implicit.getName());
                    }, ", "), "] ");
              }

              auto params = schemaLoader.get(methodProto.getParamStructType()).asStruct();
              auto results = schemaLoader.get(methodProto.getResultStructType()).asStruct();
              return kj::strTree(
                  indent.next(), methodProto.getName(),
                  " @", method.getIndex(), " ", kj::mv(implicitsStr),
                  genParamList(interface, params, methodProto.getParamBrand(), method), " -> ",
                  genParamList(interface, results, methodProto.getResultBrand(), method),
                  genAnnotations(methodProto.getAnnotations(), interface), ";\n");
            },
            genNestedDecls(schema, indent.next()),
            indent, "}\n");
      }
      case schema::Node::CONST: {
        auto constProto = proto.getConst();
        return kj::strTree(
            indent, "const ", name, " @0x", kj::hex(proto.getId()), " :",
            genType(constProto.getType(), schema, nullptr), " = ",
            genValue(schema.asConst().getType(), constProto.getValue()),
            genAnnotations(schema), ";\n");
      }
      case schema::Node::ANNOTATION: {
        auto annotationProto = proto.getAnnotation();

        kj::Vector<kj::String> targets(8);
        bool targetsAll = true;

        auto dynamic = toDynamic(annotationProto);
        for (auto field: dynamic.getSchema().getFields()) {
          auto fieldName = field.getProto().getName();
          if (fieldName.startsWith("targets")) {
            if (dynamic.get(field).as<bool>()) {
              auto target = kj::str(fieldName.slice(strlen("targets")));
              target[0] = target[0] - 'A' + 'a';
              targets.add(kj::mv(target));
            } else {
              targetsAll = false;
            }
          }
        }

        if (targetsAll) {
          targets = kj::Vector<kj::String>(1);
          targets.add(kj::heapString("*"));
        }

        return kj::strTree(
            indent, "annotation ", name, " @0x", kj::hex(proto.getId()),
            " (", strArray(targets, ", "), ") :",
            genType(annotationProto.getType(), schema, nullptr), genAnnotations(schema), ";\n");
      }
    }

    return kj::strTree();
  }

  kj::StringTree genNestedDecls(Schema schema, Indent indent) {
    uint64_t id = schema.getProto().getId();
    return kj::strTree(::kj::_::Mapper<decltype(::kj::_::refIfLvalue(schema.getProto().getNestedNodes()))>(schema.getProto().getNestedNodes()) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(schema.getProto().getNestedNodes()))>::Element nested) {
      return genDecl(schemaLoader.get(nested.getId()), nested.getName(), id, indent);
    });
  }

  kj::StringTree genFile(Schema file) {
    auto proto = file.getProto();
    if (__builtin_expect(proto.isFile(), true)) {} else for (::kj::_::Debug::Fault f("/mnt/a/oe/build/tmp/work/aarch64-bec-linux-musl/capnproto/0.6.1-r0/git/c++/src/capnp/compiler/capnpc-capnp.c++", 645, ::kj::Exception::Type::FAILED, "proto.isFile()", "\"Expected a file node.\", (uint)proto.which()", "Expected a file node.", (uint)proto.which());; f.fatal());

    return kj::strTree(
      "# ", proto.getDisplayName(), "\n",
      "@0x", kj::hex(proto.getId()), ";\n",
      ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(proto.getAnnotations()))>(proto.getAnnotations()) * [&](typename ::kj::_::Mapper<decltype(::kj::_::refIfLvalue(proto.getAnnotations()))>::Element ann) { return genAnnotation(ann, file, "", ";\n"); },
      genNestedDecls(file, Indent(0)));
  }

  kj::MainBuilder::Validity run() {
    ReaderOptions options;
    options.traversalLimitInWords = 1 << 30;
    StreamFdMessageReader reader(0, options);
    auto request = reader.getRoot<schema::CodeGeneratorRequest>();

    for (auto node: request.getNodes()) {
      schemaLoader.load(node);
    }

    kj::FdOutputStream rawOut(1);
    kj::BufferedOutputStreamWrapper out(rawOut);

    for (auto requestedFile: request.getRequestedFiles()) {
      genFile(schemaLoader.get(requestedFile.getId())).visit(
          [&](kj::ArrayPtr<const char> text) {
            out.write(text.begin(), text.size());
          });
    }

    return true;
  }
};

}
}

int main(int argc, char* argv[]) { ::kj::TopLevelProcessContext context(argv[0]); capnp::CapnpcCapnpMain mainObject(context); return ::kj::runMainAndExit(context, mainObject.getMain(), argc, argv); };